5：面向对象总结

高级类特性

Staitc：关键字，用于修饰类的成员（属性、方法、内部类）。

例如每一个中国人都共享这个国家的名称，不需要为每个中国人的实例对象中单独分配一个用于代表国家名称的变量。

1. 在访问允许的情况下，static修饰的成员可以通过类名.的方式访问，在不创建对象实例的情况下也可以
2. Static修饰的成员叫类成员，为类的所有实例所共享
3. 在static方法内部只能访问类的static属性，不能访问类的非static属性。但是，非static方法可以访问static成员
4. 因为不需要实例就可以访问static方法，因此static方法内部不能有this和super
5. 静态初始化：static修饰的代码块，当类被加载时执行，且被执行一次，作为对静态属性的初始化

设计模式：像经典的棋谱，不同的棋局用不同的棋谱，免去我们自己再去思考和探索

单子设计模板：也就是类的单态设计模式，即采取一定的办法保证软件系统中，对某一个类只能存在一个对象实例。

具体的操作：

1. 在类的外部不能通过new构造器的方式创建实例。所以把构造器私有化
2. 因为在类的外部不能创建类的实例，那只能在类的内部创建
3. 为了让类的外部可以直接使用该实例，使用static修饰（因为static修饰的成员可以不用new的方式，直接通过类名.的方式访问）
4. 不能在类的外部修改属性：私有化该属性。同时提供共有的get方法来访问

Eg:

private static person p=new person();

Public static person getp(){ return p};

Final：关键字，可以修饰类、属性和方法，表示最终的。

1.Final修饰的属性是最终的属性，所以不能修改，即常量

2.Final修饰的方法是最终的方法，所以不能修改，即不能重写

3.Final修饰的类是最终的类，所以不能扩展，即不能继承

注意：

必须在声明时被初始化，可以在非静态代码块中，或在构造器中来初始化

Eg:

Class a{

Final int age;{age=12;}//静态代码块中初始化

Final string name=“”；//string类型加上引号

Final int sex;

Aa(){sex=1;}}//在构造器中初始化

Abstract:关键字，用于修饰类和方法。

1. abstract修饰的方法：没有方法体，只有方法的声明
2. Abstract修饰的类：抽象类，不能被实例化

注意：

1.有抽象方法的类一定是抽象类，但抽象类中可以没有抽象方法

2.不能用abstract修饰私有方法、构造方法、静态方法

用法：

1)抽象类不可实例化

2)具体的类通过继承抽象类的方式，创建子类的实例

3)当子类继承抽象类以后，要重写抽象类的抽象方法

4)子类必须重写抽象类及其父类的所有的抽象方法，方可实例化。如果不重写，输出的则是抽象类中默认的方法。抽象类继承抽象类可以不用写抽象方法，已经继承了。

public class TestAbstract {

public static void main(String[] args) {

Person p1 = new Student();//多态

p1.talk();

p1.work();

应用场景：

1. 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法（例如圆和矩形都有面积的计算公式，父类可以定义一个空的面积的方法，在比较俩个图形面积大小的时候）
2. 从多个具有相同特性的类中抽象出一个类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性

接口：有时候必须从几个类的中派生出一个子类，继承他们所以的属性和方法。但是Java中不支持多重继承，即只能有一个父类。有了接口，就可以实现多继承。

接口定义了某一些类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

从本质上讲，接口是一种特殊的抽象类，这种抽象类只包含常量和方法的定义，而没有变量和方法的实现。

1. 使用interface声明
2. 接口是抽象方法和常量的集合，不能再有其他成分
3. 接口方法中默认修饰为：public abatrac
4. 接口中常量的默认修饰为：public static final

常量的命名规范：多个单词组成，每个字母需要大写，且每个使用_连接。

1. 实现接口使用implements关键字
2. 一个类可以实现多个接口，接口可以继承，或者说就是为了继承

修饰符 class 类名 extends 父类implements 接口1，接口2。。。

{类体部分 ，如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法}

注意：

1. 不能用private和protect修饰接口，通常用public
2.  抽象类可以定义构造器！---->接口是没有构造器的！

总结：

staitc是为了共享属性、方法和内部类，可以不用实例化通过类名.的方式访问。

单子模式是只能有一个对象实例，但是不能在类外面实例化，只能在内部实例化，所以先私有化构造器，再私有化属性，并提供get方法。前边都用static，实例也要用stait,比如

private static person p=new person();

Abstract修饰的方法抽象方法是没有方法体的，修饰的类抽象类是不能实例化的。抽象类是知道有哪些方法，但具体如何实现交给子类。

接口是只有抽象方法和常量的抽象类，它可以实现多继承，它不关心细节，只需提供必须有的东西。

内部类：在类的内部定义的类

1. 在类的外部如何访问内部类对象？

①对于非静态内部类：必须先创建外部类对象，然后再创建内部类对象

OuterClass oc=new OutClass();

InnerClass ic=oc.new InnerClss();

ic.test();

②静态内部类：内部使用static来修饰，所以创建该类的对象可以没有外部类对象

StaticInnerClass sic=new Outclass.StaticInnerClass;

2.内部类通过以下方式访问外部类的成员变量

Private int i=1;//外部类的成员变量

Class innerclass{

Private int i=2;

Private string innername=”def”

Public void tese(){

Int i=3;

Sysout(i);//3

Sysout(this.i);//2

Sysout(outclass.this.i)；

//1     如果外部成员变量是int a=1,这里直接写就行

Sysout(outername);

Sysout(innername);

//访问方法时正常访问即可

}

}

注意：静态内部类中的方法不能访问外部内的非静态成员

1. 匿名内部类

在类的内部直接创建一个接口的实现类对象                            

Eg:

New IplayGame（）{

Public void playGame(){

Sysout(用匿名内部类实现接口)}

}.playGame（）；

也可以在类的内部这样写：

IplayGame ip= new iplayGame(){

   Public void playGame(){

   Sysout(“使用匿名内部类实现接口”)}}；

   Ip.playGame();//通过这样访问这个方法