笔记——Java基础[03-面向对象概述]

3.1 面向对象的概念

1、面向过程：强调的是功能性为。面向对象：将功能封装进对象，强调了具备功能的对象。

2、面向对象三个特征：封装、继承、多态。

3、开发就是找对象使用，没有对象就创建一个对象。

3.2 类与对象的关系

1、类：对现实生活中事物的描述。对象：就是这类对象，实实在在存在的个体。

2、描述事物就是描述属性和行为（成员变量和成员函数）。

3、可以多个引用指向同一个对象。

4、成员变量作用于整个类中，局部变量作用于函数中或者语句中。成员变量在堆内存中，因为对象的存在才在内存中存在。局部变量：存在栈中。

class Car{//颜色String color = "红色";//显示初始化//轮胎数int num = 4;//行为void run(){System.out.println(color+".."+num);}}class Demo {public static void main(String[] args){//通过new操作符来完成。Car c = new Car();Car c1 = new Car();c.color = "blue";c1.color = "green";c1 = c;c.run();} }

5、在定义的类中也可以定义主函数，表示这个类可以独立的运行，不过一般不这样写。

6、匿名对象是对象的简化形式。匿名对象两种使用情况：（1）当对对象方法仅进行一次调用的时，多次成员调用必须起名字。（2）匿名对象可以作为实际参数进行传递，例如show(new Car())。

3.3 封装

1、封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

2、权限修饰符。private：私有，用于修饰类中的成员（包括成员，成员函数），私有仅仅是封装的一种形式。

3、setAge()，getAge()，之所以提供访问方式，就因为可以在访问方式中加入逻辑判断语句。

3.4 构造函数

1、特点：（1）函数名与类名相同，（2）不用定义返回值类型，（3）不可以写return语句。

2、对象已建立就调用构造函数，同c++。当无显示构造函数时，自动给该类加一个Person(){}样的构造函数。

3、构造函数可以重载！

4、构造函数没法显示调用，在对象创建的时候自动调用。一般函数可以被调用多次。

5、构造代码快，作用：给对象进行初始化，对象一建立就运行，优于构造函数执行。区别：构造函数是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。因为构造函数可以有多个，每个对象对应某个。既共性的定义在构造代码快。

3.5 this关键字

1、this：看上去是区分去不变量和成员变量的区别。this代表它所在函数所属对象的引用。变量出现重名的情况时候必须加，其他情况可省略。

Person(String name){this.name = name;}

2、this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象，这时用this来表示这个对象。但凡本类功能内部使用了本类对象，都用this表示。

3、构造函数间调用只能用this语句，且只能定义在第一行，因为初始化要先执行。例如：this(name)。

Person(String name){this.name = name;}Person(String name, int age){this(name);this.age = age;}

4、this语句有可能出现死循环，注意避免。

3.6 static关键字

1、用法：是一个修饰符，用于修饰成员（成员变量和成员函数）。静态修饰内容被对象所共享。

2、当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。

3、类变量（成员、函数）随着类的加载存放在共享区（方法区、数据区）。

4、特点：

（1） 静态的（类变量）随着类的加载（消失）而加载（消失），非静态的（成员变量、实例变量）对象创建时才创建。

（2）优先于对象存在。

（3）被所有用户所共享。

（4）可以直接被类名调用。

5、为什么不把所有都定义为静态：

（1）和现实世界相对应。

（2）对内存消耗很大。

6、使用注意事项：

（1）静态方法只能访问静态成员（方法和变量），非静态可以访问非静态和静态的。

（2）静态方法中不可以定义this，super关键字。因为静态优先于对象存在，所以静态方法中不可以出现this字样。

（3）主函数是静态的。

7、静态有利有弊：

利：对对象的共享数据进行单独空间的存储，没有必要每个对象都存储一份。可以直接被类名调用。

弊：生命周期过长，访问出现局限性。（静态虽好，只能访问静态。）

class Person{String name;static String country = "CN";public static void show()//注意会报错，因为静态只能访问静态。name不是静态。{System.out.println(name+"::"+country);}}class PersonDemo {public static void main(String[] args){Person p = new Person();//p.name = "zhangsan";//p.show();//System.out.println(Person.country);Person.show();}}

8、主函数：是一个特殊的函数，作为程序的入口，可以直接被jvm调用。

主函数的定义：public代表函数的访问权限是最大的。

static：表示主函数随着类的加载已经存在了。

void：函数无返回值。

main：不是关键字，但是是一个特殊的单词，可以被jvm检测到。

（String [] args）：函数的参数，参数的类型是一个数组，该数组中的元素是字符串。字符串类型的数组。args是来自 arguments（参数），但是也可以改。

jvm在调用主函数的时候传入的是new String[0]

9、是什么时候静态：

（1）静态变量：当对象中出现共享数据时。

（2）静态函数：当功能内部没有访问到非静态数据（对象的特有数据）时。可以用类名直接调用。

10、静态的应用：

（1）可以定义某些类只包含操作函数，例如视频中的ArrayTool，建了ArrayTool的对象后，可以使用里边封装的函数。

（2）但是ArrayTool并没有封装特有数据，函数也没有用到特有数据。

（3）所以是不需要对象的，可以将ArrayTool中的函数定义成static的，直接通过类名调用即可。

（4）但是该类还是可以被其他程序建立对象。为了更为严谨，强制让该类不能创建对象，可以通过将构造函数私有化完成。

10、要生成文档的类必须是公有的，加public。私有的不再文档中显示。

11、一个类中默认会一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。类是public的，则构造函数也是public的。

12、API 应用程序接口。

13、JDK API 就是java的文档。

14、静态代码块：

格式

static {System.out.println("a");}

特点：随着类的加载只执行一次。

作用：用于给类初始化的。

区别：静态代码块给类初始化，构造代码块给对象初始化，构造函数给对应对象初始化的。顺序也是这个顺序。

class StaticCode{static {System.out.println("a");}/*public static void show(){System.out.println("show run");}如果StaticCode没有对象，但是通过StaticCode.show调用，也加载静态代码块。*/}class StaticCodeDemo {static {System.out.println("b");}public static void main(String[] args){new StaticCode();new StaticCode();System.out.println("over");}static {System.out.println("c");}}//输出结果是b c a over。注意只有一个a 

15、对象的构造过程Person p = new Person("zhangsan", 20);

该句话都做了什么事情？

（1）应为new 用了Person.class，所以会先找到Person.class文件并加载到内存中。

（2）执行该类的静态代码快（如果有的话），给Person.class类进行初始化。

（3）在堆内存中开辟空间，分配内存地址。

（4）在堆内存中建立对象的特有属性，并进行默认初始化（指的是null和0）。

（5）对属性进行显示初始化（指的是例如String name = “哈哈”）。

（6）对属性进行构造代码块初始化。

（7）对属性进行与之对应的构造函数初始化。

（7）将内存地址赋给栈内存中p变量。

3.7 单例设计模式

1、设计模式：解决某一类问题最行之有效的方法：java中有23种设计模式。其中一种叫单例设计模式：解决一个类在内存中只有一个对象。

2、想要保证对象唯一：

（1）为了 避免其他程序过多建立该类对象，先禁止其他程序建立对象。

（2）还为了让其他程序可以访问该类对象，只好在本类中自定义一个对象。

（3）为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

3、代码体现：

（1）将构造函数私有化。

（2）在类中创建一个本类对象。

（3）提取一个方法可以获取到该对象。

（饿汉式）

class Single{private Single();private static Single s = new Single();public static Single getInstance();{return s;}}class SingleDemo {public static void main(String [] args){Single ss = Single.getInstance();}}

（懒汉式）

class Single{private static Single s= null;private static Single(){};public static Single getInstance();{if (s == null)s = new Single();return s;}}

对象是方法被调用时才初始化，也叫做对象的延时加载。

Single类进内存时对象还没有存在，只有调用了了getInstance方法时，才建立对象。

4、当需要保证唯一时将上述三步加上即可。

5、建议使用饿汉式。