JAVA中的面向对象初学（持续总结更新...）

面向对象三个特征：封装，继承，多态

类定义完成后需要声明并实例化对象，而实例化操作时的引用数据类型，如String,int等，都需要关键字new来分配堆空间，如果只是声明对象而不进行实例化操作，就会出现空指向异常的错误。

实例化之后，访问属性或方法时用“对象.属性/方法”

引用传递：

同一块堆内存间被多个栈空间地址所指向，不同的栈可以修改同一堆内存的内容。如果堆内存空间没有任何对象指向，就会成为垃圾数据等待GC回收。

封装：

类中属性或方法加上private，使之只能被本类中对象所操作。如果类外想操作，需要先在类内用setter,getter写对外接口对象（方法），因为该方法时public的，所以类外可以调用。如果想检测类外传输的数据是否正确，可以先在接口对象方法中写验证代码。

构造方法

构造方法在实例化对象的时候使用，且对象的构造方法只会显示调用一次，且堆内存的空间分配只有在执行构造函数后才会进行。普通方法在实例化对象之后使用。

构造方法的名称和类名称一致，不允许有返回值类型声明。如果类中没有明确定义构造方法，则会自动生成一个无参数的，无返回值的构造方法。一个类中至少存在一个构造方法。即类中一定存在至少一个构造方法。

构造方法的编写顺序强调有个顺序编写，如按照参数的个数多少。

匿名对象

没有栈指针指向的堆内存空间，只能一次性使用，使用完毕成为垃圾

this指针

表示  、 强调本类中的方法调用或属性操作。

JAVA中this的作用：表示本类属性，本类方法，当前对象

本类属性：构造函数中定义属性内容，当要明确指定操作的是类中属性的时候。

本类方法：一个类中有多个构造方法，多个构造方法内部的参数部分重复，可以用this来完成构造方法之间的互相调用操作。this()调用构造方法的操作一定要在构造方法的首行。

当前对象：当前正在调用本类方法。

String类

string类的构造：public String(String str)实现对象实例化

== 比较字符串内存地址的数值

equal()比较两个字符串的内容

字符串常量是String类的匿名对象

两种实例化对象：

1，直接赋值：无论实例化多少个对象，只要是赋值的字符串常量相同，开辟堆内存只有一块，所有的堆内存都被多个栈内存所指向，自动入池。

2，构造方法赋值：实际上会开辟两块空间，一块将成为垃圾。实例化的对象不会自动入池。可手工入池：public  String  intern()。

字符串的内容一旦声明则不可改变，如删，增字符，因为字符串内容的改变，实际上改变的是字符串对象的引用过程，使存储在栈内存的对象指针不断改变堆内存的地址，改变后的堆内存就成了垃圾。

对象比较：equals()

语法：

public boolean equals(Object anObject)

即括号内部表示的是该对象字符串，不是要比较的字符串。而字符串常量是匿名对象，不为空null。也就是在equal前面的对象字符串不能为null，只能是具体的某个需要比较的字符串，如：

public class TestDemo {public static void main(String args[]) {                   String str = null ;          // 假设是输入的                   if ("HELLO".equals(str)) {                            System.out.println("条件满足。") ;                   }         }}

static

用于定义属性和方法，使之和普通属性/方法区分，表示公共的概念，独立于类之外，定义的属性属于全局数据区。（普通属性保存在堆内存中）

static定义的属性表示类属性，调用方式：通过“类名称.static属性”完成。

static定义的属性或方法可以在没有实例化对象的时候使用，非static定义的属性和方法，必须实例化对象后才可以进行调用。因此不能调用非static的方法或属性。

内部类

指的是一个类的内部定义了其他类的情况。

优点：使内部类和外部类可以方便的互相访问彼此的私用操作，不需要set,get。但是内部想表示外部类的当前对象时，应该用“外部类.this.”。

缺点：使外部类除了属性和方法外又多了一个类，破坏了程序的结构

外部类实例化内部类的对象：

外部类.内部类    内部类对象 = new   外部类（）.new   内部类（）；

之所以要先实例化外部类对象，是因为内部类需要访问外部类的普通属性，而普通属性只有在对象实例化之后才会被实例化。

如果内部类在android开发中，大多对其进行封装。

内部类被static定义后，就会表示成”外部类“，只能访问外部类中的static属性。

方法中定义内部类，内部类访问方法的参数或变量时，这些参数和变量前一定要加final，只是作为标记

继承性

语法：class  子类    extends   父类{ }

子类即派生类，父类即超类

继承的限制：

1，一个子类只能继承一个父类，单继承局限。Java只允许多层继承，不允许多重继承。

2，子类可以直接利用对象操作显示继承父类非私有操作，对于所有私有操作，只能隐式继承或间接完成，比如用setter，getter方法

3.默认情况，子类会先调用父类的无参构造函数，相当于子类的构造函数中一定会有父类的super()构造函数，且一定要放在构造方法的首行上。想让子类不去调用父类构造是不可能的。

覆写

子类有和父类完全相同的方法和属性的名称，返回值类型，参数类型和个数的方法，该方法就称为方法的覆写。

当类中的方法被覆写之后，如果实例化的是这个子类对象，则调用的方法是覆写过的方法。

局限：

被子类覆写的方法的方法一定要比父类更容易访问，加入父类的方法时default权限，子类覆写只能是default或public权限。父类是public，则子类只能是public。但是，如果父类定义了private的方法，则子类无法真正去覆写父类的方法。

属性的覆写，即子类和父类的属性名称一样，这种操作没有意义。因为属性一定要封装，封装之后就没有覆写的概念了。

this.方法（）：先从本类查找指定的方法，如果没有，就调用父类的操作方法。要放在首行。

super.方法（）：直接从子类调用父类的指定方法。要放在首行。

重载：方法名称相同，参数类型和个数不同。可以改变返回值类型。

覆写：方法，参数类型和个数，返回值类型完全相同。发生在继承关系类中，被子类覆写的方法不能拥有比父类更严格的访问控制权限。

final

1，final定义的类不能有子类

2，final定义的方法不能被子类覆写

3，final定义的变量表示常量，无法修改。再加上public static，就表示全局常量。且变量标识符都要大写。

设计模式

单例设计模式

从构造方法被私有化说起。

当构造方法私有化时，外部就无法调用，只能本类调用，即无法在外部实例化该类的对象，只有本类才能产生实例化对象；

但是，如果一个类中存在普通属性，而普通属性一定要在本类存在了实例化对象后才能进行调用，而此时类外不能产生实例化对象，这个时候可用static定义，实质可以在没有实例化对象的时候调用。

构造方法私有化只能通过get方法取得本类中的实例化对象，不管外部如何操作，最终只有一个实例化对象。在单例设计模式中，一定存在static方法，用于取得本类中的实例化对象。

多例设计模式

多态性

方法多态性：重载，覆写

对象多态性：父子类对象的转换

1，向上转型：子类对象变为父类对象，格式：父类 父类对象 = 子类实例，自动；

2，向下转型：父类对象变为子类对象，格式：子类 子类对象 = (子类) 父类实例，强制；

3，不转型。

向下转型操作可能会出现问题，可先判断某一对象是否是某一对象的实例，可用instanceof关键字，返回的是boolean

抽象类

包含的抽象方法只声明未实现。抽象方法一定要在抽象类中，用abstract定义。抽象类除了抽象方法外，还有普通方法，属性，而属性必须在构造方法执行完毕才可以初始化操作，也就是，抽象类可以包含构造方法来初始化属性。反过来，抽象类可以没有抽象方法，此时不能够被直接实例化。

抽象类必须有子类继承，且一个子类只能继承一个抽象类。所以抽象类不能用final定义。

如果子类不是抽象类，必须覆写抽象类中的全部抽象方法

抽象类对象可用对象的向上转型方式，通过子类进行实例化操作

外部抽象类不能使用static声明。

应用：模板设计模式

接口

类定义的时候全部由抽象方法和全局常量组成，无法直接对象实例化。关键字interface。

使用原则：

1，每个接口必须定义子类，子类用implement关键字实现。

2，如果子类不是抽象类，必须覆写接口定义的全部抽象方法。

3，子类对象实例化操作采用向上转型

一个子类可以同时实现多个接口，但是只能继承一个父类。如果一个类既要实现接口又要继承抽象类，应该先继承后实现。接口的访问权限只有public。

一个接口不能继承抽象类，可以继承多个接口。

应用：工厂设计模式（中间有过渡操作）

代理设计模式