第十章 面向对象编程（高级部分）

第十章 面向对象编程（高级部分）

10.1 类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问他，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

(1)static 变量是同一类所有对象共享

(2)static类变量，在类加载的时候就生成了

//定义语法：
    访问修饰符 static 数据类型 变量名;【推荐】
    static 访问修饰符 数据类型 变量名;

//如何访问类变量
    类名.类变量名
    或者  对象名.类变量名
    注：静态变量的访问修饰符的访问权限和范围 和 普通属性一样
        类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问

10.2 类方法

类方法也叫静态方法：
    形式如下：
    访问修饰符 static 数据返回类型 方法名(){ }
	static 访问修饰符 数据返回类型 方法名(){ }

	使用方式：
        类名.类方法名 或者 对象名.类方法名

10.3深入理解main方法

特别提示：

1. 在main()方法中，我们可以直接调用main 方法所在类的静态方法或静态属性。
2. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，

10.4代码块

代码块又称为初始化块，属于类中的成员，【即，是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或者类显示调用，而是加载类，或对象时隐式调用。

//基本语法
[修饰符]{
    代码
};
说明注意：
    1）修饰符可选，要写的话，也只能写static
    2）代码块分为两类，有static修饰得成为静态代码块；没有的称作普通代码块\非静态代码块
    3）逻辑语句上可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）
    4）;号可以写，也可以省略。
    5）不管调用哪个构造器，创建对象，都会先调用代码块的内容
	6) 代码块调用的顺序优先于构造器..

代码块使用注意事项和细节讨论：

10.5 单例设计模式

什么是设计模式：

1. 静态方法和属性的经典使用
2. 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决之后问题的思考方式，设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己在思考和摸索。

单例模式：

1. 所谓的类的单例模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个实例对象，并且该类只能提供一个取得其对象示例的方法。
2. 单例模式有两种方式：饿汉式和懒汉式

//步骤[单例模式-饿汉式] 
//1. 将构造器私有化 
//2. 在类的内部直接创建对象(该对象是 static) 
//3. 提供一个公共的 static 方法，返回 gf 对象


//步骤 [懒汉式]
//1.仍然构造器私有化
//2.定义一个 static 静态属性对象 
//3.提供一个 public 的 static 方法，可以返回一个 Cat 对象 
//4.懒汉式，只有当用户使用 getInstance 时，才返回 cat 对象， 后面再次调用时，会返回上次创建的 cat 对象 - 从而保证了单例

10.6 final关键字

10.7 抽象类（abstract）

当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

//即： 父类方法不确定性的问题 
//===> 考虑将该方法设计为抽象(abstract)方法
//===> 所谓抽象方法就是没有实现的方法 
//===> 所谓没有实现就是指，没有方法体 
//===> 当一个类中存在抽象方法时，需要将该类声明为 abstract 类 //===> 一般来说，抽象类会被继承，有其子类来实现抽象方法

10.8 接口

	接口就是给出一些没有实现的方法，封装到一起，起到某个类使用的时候，再根据具体情况把这些方法写出来。
语法：
interface 接口名{
        //属性
        //抽象方法（可以省略abstract关键字）
    }

class 类名 implements 接口{
    自己属性；
    自己方法；
    必须实现的接口和抽象方法
}

//小结：接口是更加抽象的抽象类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低耦合的设计思想。

//特别说明： JDK8.0后接口类可以有静态方法，默认方法，也就是接口中可以有方法的具体实现。
 

//继承

小结: 当子类继承了父类，就自动的拥有父类的功能

如果子类需要扩展功能，可以通过实现接口的方式扩展.

可以理解 实现接口 是 对 java 单继承机制的一种补充.

接口的多态特性：

10.9 内部类

基本语法：
    class Outer{//外部类
        class Inner{//内部类
        }
    }
	class Other{
        //外部其它类
    }

内部类的分类：（四种）
如果定义在外部类局部位置(放在方法中/代码块) :
	(1) 局部内部类（有类名） (2) 匿名内部类（没有类名，重点！）

定义在外部类的成员位置：
    (1) 成员内部类（没有static修饰） (2) 静态内部类（有static修饰）

局部内部类的使用：

1. 可以直接访问外部类的所有成员，包含私有的

2. 不能添加访问修饰符，因为他的位置就是一个局部变量，局部变量不能使用访问修饰符，但是可以使用final修饰，因为局部变量也可以使用final

3. 作用域：仅仅在定义它的方法或者代码中

4. 局部内部类----访问---->外部类的成员【访问方式：直接访问】

5. 外部类----访问------>局部内部类【访问方式：先创建对象，在访问（注意必须在作用域内）】

   • 记住：局部内部类定义在方法\代码块中
   • 作用域在方法体或者代码块中
   • 本质仍然是个类

6. 外部其它类—不能访问---->局部内部类（因为局部内部类地位是个局部变量）

7. 如果外部类和局部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

   System.out.println("外部类的n2 = " + 外部类名.this.n2)

匿名内部类的使用(重要!!!):

1. 本质是类

2. 内部类

3. 该类没有名字

4. 同时还是一个对象

   说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名。
   
   基本语法
   new 类或接口（参数列表）{
   	类体
   	};
   

5. 匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征

6. 可以直接访问外部类的所有成员，包含私有的

7. 不能添加访问修饰符，因为地位就是一个局部变量

8. 作用域：仅仅在定义它的方法或代码块中

9. 匿名内部类-----访问----->外部类成员【访问方式：直接访问】

10. 外部其它类-----不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量）

11. 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问；

成员内部类的使用：

​ 说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

1. 可以直接访问外部类所有成员，包含私有的
2. 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。
3. 作用域和外部累的其他成员一样，为整个类体
4. 成员内部类-----访问---->外部成员（比如属性）[访问方式：直接访问]
5. 外部类--------访问------->成员内部类【访问方式：创建对象在访问】
6. 外部其他类----访问-----成员内部类
7. 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类成员，则可以使用，外部类名.this.成员去访问

静态内部类的使用：

​ 说明：静态内部类是定义在外部类的成员位置，并且有static修饰

1. 可以直接访问外部类的所有静态成员，包含私有的，但不能访问非静态成员
2. 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。
3. 作用域和外部累的其他成员一样，为整个类体
4. 静态内部类—访问—>外部类（比如：静态属性）【访问方式：直接访问所有静态成员】
5. 外部类—访问—>静态内部类 【访问方式：创建对象，在访问】
6. 外部类—访问—>静态内部类
7. 如果外部类和静态内部类的成员重名时，静态内部类访问的话，默认遵循就近原则，如果想访问外部类成员，则可以使用，外部类名.成员去访问