黑马程序员技术交流社区

标题: java自学笔记04 [打印本页]

作者: 阿秋    时间: 2015-7-22 17:55
标题: java自学笔记04
/*面向过程*/
1.从Day1到Day4期间学习的都是面向过程,具体表现为一个类中包含一个主函数和多个其他函数。
2.强调的是功能行为,因为对象只有一个。
/*面向对象*/
面向对象是基于面向过程而言的,将功能封装进对象,强调了具备功能的对象。
/*成员变量和局部变量*/
成员变量:作用于整个类中,在堆内存中,有默认初始化值
局部变量:作用于一个函数中,存在于栈内存中,无默认初始化值
/*栈内存和堆内存*/
简单来说,栈就是一个很长的栈(数据结构中的栈,如果不理解可以当做是像线一样的一长串数据)。
里面存着各种逻辑,以及像整形,浮点型等数据,根据栈先进先出的原则,代码会一条条被执行,执行代码中包含着栈中可以存放的数据。
但数据量过大的时候,存入栈中会明显影响性能。所以,我们将大量的数据存入堆中,之后,栈中放堆的地址。//栈中通过堆内存的储存大量数据再通过地址来进行调用。
这样,在进行数据调用的时候,可以通过地址找到对应数据。//实际数据放入堆内存,而栈内存则只是调用地址
例子:
        Person p=new Person("阿秋",20)                //其中p(相当于地址)在栈内存当中,而类似于"阿秋",20等数据在推内存当中。
/*面向对象格式*/
class Q1
{
        public static void main(String[] args)
        {
                Car c=new Car();
                c.run();
                //法二:
                //Car.run();
                Dog d=new Dog();
                d.run();
        }
}
class Car
{
        static String name="兰博基尼";
        static int price=10000000;
        public static void run()        //因为run()方法用static修饰,所以其打印语句用的变量也必须是静态。
        {
                System.out.println("阿秋的豪车是:"+name+",价格是:"+price+"$");
        }
}
class Dog
{
        String name="小黑";
        void run()                                        //没有用static修饰,所以变量也不用static静态。
        {
                System.out.println("名字是:"+name);
        }
}
/*面向对象特征一:封装*/
封装:隐藏对象的实际属性和实现方法,仅对外提供公共访问方式。
好处:1.将变化隔离
          2.提高复用性
          3.提高安全性
/*封装的标志性语法*/
set和get:一个是赋值一个是取值。
class Q1
{
        public static void main(String[] args)
        {
                Person p=new Person();
                p.setName("阿秋是天才");
                System.out.println(p.getName());
        }
}
class Person
{
        private String name;                                        //私有只在本类中有效
        public void setName(String name)                //赋值
        {
                this.name=name;                                                //void修饰的是没有具体返回值类型的情况,除了打印语句之外还可以有赋值语句
        }
        public String getName()
        {
                return name;                                                //取值
        }
}
/*构造函数*/
构造函数的特点:
1.函数名和类名相同
2.不用定义返回值
3.不用写return语句
构造函数书写方式:
        例如:Person(){}                                                //函数名和类名相同
class Q1
{
        public static void main(String[] args)
        {
                Person p=new Person();
                new Person();
        }
}
class Person
{
        Person()
        {
                System.out.println("aaaa");
        }
}                                                                                        //打印结果是aaaa和aaaa,原理对象只要已建立,不论是带名称的还是匿名的对象,就会调用其自带的构造函数
                                                                                        //每一个函数都自带一个空参的构造函数,打印结果为空
/*构造函数的重载*/
/*完成改名字的动作*/
class Person
{
        private String name;
        private int age;
        {
                System.out.println("中文");                                        //因为可能会出现所有构造函数都共有的一些代码,则发明出构造代码块解决这个问题                               
        }                                                                                                //构造代码块优先于构造函数执行
        Person()
        {
                System.out.println("A.name="+name+",age="+age);
        }
        Person(String name)
        {
                this.name=name;
                System.out.println("B.name="+name+",age="+age);
        }
        Person(String name,int age)
        {
                this.name=name;
                this.age=age;
                System.out.println("C.name="+name+",age="+age);
        }
        public void setName(String name)
        {
                this.name=name;
        }
        public String getName()
        {
                return name;
        }
       
}
class Q1
{
        public static void main(String[] args)
        {
                new Person();                                                        //打印结果是:A.name=null,age=0        ,String name的默认初始化值是null                       
                new Person("阿秋");                                                //打印结果是:B.name=阿秋,age=0
                Person p=new Person("阿秋",22);                        //打印结果是:C.name=阿秋,age=12
                p.setName("邱锐刚");
                System.out.println(p.getName());
        }                                                                                        //构造函数建立对象不需要额外的Person p
}
/*this关键字*/
this:表面是用于区分同名对象的方法
                1.它代表了本类对象
                2.更细致的说是代表了所在函数所属对象的引用
/*定义个功能,可以比较2个人的年龄是否相同*/
class Person
{
        int age;                                                                        //在构造函数中的形参(局部变量)并不能代表全局变量,必须在类中定义全局的int age才能编译运行。
        Person(int age)
        {
                this.age=age;
        }
        public boolean compare(Person p)
        {
                return this.age==p.age;                                        //对于boolean类型用==符号
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Person p1=new Person(22);
                Person p2=new Person(23);
                boolean b=p1.compare(p2);                                //b为boolean类型,用boolean进行修饰
                System.out.println(b);
        }
}
/*构造函数间this关键字的调用*/
/*构造代码块的应用*/
class Person
{
        String name;
        int age;
        {
                System.out.println("阿秋是天才");                                                        //构造代码块
               
        }
        Person()
        {
        }
        Person(String name)
        {
                this.name=name;
        }
        Person(String name,int age)
        {
                this(name);                                                                                                        //1.在多个构造函数之前调用重复性很高的东西,用this(name)形式
                this.age=age;                                                                                                //2.对于this语句只能定义在构造函数的第一行。
        }
        public void speak()
        {
                System.out.println("name是:"+name+",年龄是:"+age);
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Person p1=new Person("阿秋",22);
                Person p2=new Person("阿秋");
                p1.speak();
                p2.speak();
//打印结果为:
/*
阿秋是天才
阿秋是天才
name是:阿秋,年龄是:22
name是:阿秋,年龄是:0                                                                                                //通过结果可以看出构造代码块是优先于对象执行的,无论是本类还是其他的
*/
        }
}






欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2