JavaSE面向对象面向过程的思维模式面向过程的思维模式是简单的线性思维，思考问题首先陷入第一步做什么、第二步做什么的

面向过程的思维模式

面向过程的思维模式是简单的线性思维，思考问题首先陷入第一步做什么、第二步做什么的细节中。这种思维模式适合处理简单的事情。

面向对象的思维模式

面向对象的思维模式说白了就是分类思维模式。思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

ava的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程(Object-Oriented

Programming, OOP)。

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。

抽象(abstract)

忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用关注细节。

例如:要设计一个学生成绩管理系统，那么对于学生，只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。抽象是什么?就是将多个物体共同点归纳出来，就是抽出像的部分！

封装(Encapsulation)

封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过指定的方式。

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。

封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

继承(inheritance)

继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。

新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。

派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

多态(polymorphism)

多态性是指允许不同类的对象对同一消息作出响应。

多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

相同类域的不同对象,调用相同方法,表现出不同的结果

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

从代码运行角度考虑是先有类后有对象。类是对象的模板。

类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。对象是抽象概念的具体实例。

对象和引用的关系

引用 "指向" 对象

使用类类型、数组类型、接口类型声明出的变量,都可以指向对象,这种变量就是引用类型变量,简称引用。

在程序中,创建出对象后,直接使用并不方便,所以一般会用一个引用类型的变量去接收这个对象,这个就是所说的引用指向对象.

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

必须和类的名字相同
必须没有返回类型,也不能写void

构造器的作用:

使用new创建对象的时候必须使用类的构造器
构造器中的代码执行后,可以给对象中的属性初始化赋值

public class Student{ private String name; public Student(){ name = "tom"; } }

构造器重载

public class Student{ private String name; public Student(){ name = "tom"; }public Student(String name){ this.name = name; } }

构造器之间的调用

使用this关键字,在一个构造器中可以调用另一个构造器的代码。

注意:this的这种用法不会产生新的对象,只是调用了构造器中的代码而已.一般情况下只有使用new关键字才会创建新对象。

public class Student{ private String name; public Student(){ this(); }public Student(String name){ this.name = name; } }

默认构造器

在java中,即使我们在编写类的时候没有写构造器,那么在编译之后也会自动的添加一个无参构造器,这个无参构造器也被称为默认的构造器。

public class Student{ }main: //编译通过,因为有无参构造器 Student s = new Student();

JAVA程序运行的内存分析

栈 stack：

每个线程私有，不能实现线程间的共享！
局部变量放置于栈中。
栈是由系统自动分配，速度快！栈是一个连续的内存空间！

堆 heap：

放置new出来的对象！
堆是一个不连续的内存空间，分配灵活，速度慢！

方法区(也是堆)：

被所有线程共享！
用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）

引用类型的概念

java中，除了基本数据类型之外的其他类型称之为引用类型。
java中的对象是通过引用来操作的。(引用：reference)引用指的就是对象的地址。

属性（field，或者叫成员变量）

属性用于定义该类或该类对象包含的数据或者说静态属性。
属性作用范围是整个类体。
属性的默认初始化：在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。(数值：0,0.0char:u0000, boolean:false, 所有引用类型:null)

属性定义格式：

[修饰符] 属性类型 属性名 = [默认值]

类的方法

方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成；面向对象中，整个程序的基本单位是类，方法是从属于类或对象的。

方法定义格式：

[修饰符] 方法返回值类型 方法名(形参列表) { // n条语句 }

java对象的创建和使用

必须使用 new 关键字创建对象。

Person person= new Person ();

使用对象（引用） . 成员变量来引用对象的成员变量。

person.age

使用对象（引用） . 方法（参数列表）来调用对象的方法。

person. setAge(23)

类中就是：//静态的数据 //动态的行为

封装（数据的隐藏）

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

封装的步骤

使用private 修饰需要封装的成员变量。
提供一个公开的方法设置或者访问私有的属性

设置通过set方法，命名格式： set属性名（）; 属性的首字母要大写

访问通过get方法，命名格式： get属性名（）; 属性的首字母要大写

//set负责给属性赋值 //get负责返回属性的值 public class Student{ private String name; public void setName(String name){ this.name = name; }public String getName(){ return this.name; } }public class Test{ public static void main(String[] args){ Student s = new Student(); s.setName("tom"); System.out.println(s.getName()); }
}

作用和意义

提高程序的安全性，保护数据
隐藏代码的实现细节
统一用户的调用接口
提高系统的可维护性
便于调用者调用

良好的封装，便于修改内部代码，提高可维护性。

良好的封装，可进行数据完整性检测，保证数据的有效性。

方法重载

类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载可以提供方法调用的灵活性。

方法重载必须满足以下条件

方法名必须相同
参数列表必须不同(参数的类型、个数、顺序的不同)
方法的返回值可以不同，也可以相同。

在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

为什么需要继承？继承的作用？

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。

第二好处：为了提高代码的复用性。

extands的意思是“扩展”。子类是父类的扩展。

【注】JAVA中类只有单继承，没有多继承！接口可以多继承！

继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
```
public class student extends Person{ } 
```
子类和父类之间,从意义上讲应该具有"is a"的关系.
```
student is a person dog is a animal 
```
类和类之间的继承是单继承
父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。

父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用

父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用

父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用super关键字)。

Object类

java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)AnyClass is aObject

在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承过来的方法。(因为Object是所有类的父类)

例如:toString方法、equals方法、getClass方法等

Super关键字

子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法。

不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

super使用的注意的地方

用super调用父类构造方法，必须是构造方法中的第一个语句。
super只能出现在子类的方法或者构造方法中。
super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

super 和 this 的区别

代表的事物不一样:this代表所属方法的调用者对象。super代表父类对象的引用空间。
使用前提不一致： this在非继承的条件下也可以使用。super只能在继承的条件下才能使用。
调用构造方法：this调用本类的构造方法。super调用的父类的构造方法

方法的重写（override）

方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.
静态方法不能重写

父类的静态方法不能被子类重写为非静态方法 //编译出错
父类的非静态方法不能被子类重写为静态方法；//编译出错
子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的

重写的语法

方法名必须相同
参数列表必须相同
访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
抛出异常类型的范围可以被缩小,但是不能被扩大ClassNotFoundException ---> Exception
返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型

一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括号中代码不一样)

为什么要重写？

子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需要把方法进行重写。

方法重写的时候，必须存在继承关系。
方法重写的时候，方法名和形式参数必须跟父类是一致的。
方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <public，friendly < public )
方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系
方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

认识多态

多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性。

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

相同类域的不同对象,调用相同的方法,执行结果是不同的

子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法,如果重写了,那么调用的就是重写之后的方法。

重写、重载和多态的关系

重载是编译时多态，调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错

重写是运行时多态调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用,是运行时动态和对象绑定的)

多态的注意事项

多态是方法的多态，属性没有多态性。
编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。比如：本来是狗，我把它转成猫。就会报这个异常。
多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：

1. static方法，因为被static修饰的方法是属于类的，而不是属于实例的

2. final方法，因为被final修饰的方法无法被子类重写

3. private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的。

方法绑定(method binding)

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。

静态绑定：

在编译期完成，可以提高代码执行速度。

动态绑定：

通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。JAVA中除了fifinal类、fifinal方、static方法，所有方法都是JVM在运行期才进行动态绑定的。

多态：如果编译时类型和运行时类型不一致，就会造成多态。

instanceof和类型转换

public class Person{ public void run(){} }public class Student extends Person{ }public class Teacher extends Person{ } 

main: Object o = new Student(); System.out.println(o instanceof Student);//true System.out.println(o instanceof Person);//true System.out.println(o instanceof Object);//true System.out.println(o instanceof Teacher);//false System.out.println(o instanceof String);//false \--------------------------- Person o = new Student(); System.out.println(o instanceof Student);//true System.out.println(o instanceof Person);//true System.out.println(o instanceof Object);//true System.out.println(o instanceof Teacher);//false //编译报错 System.out.println(o instanceof String); \--------------------------- Student o = new Student(); System.out.println(o instanceof Student);//true System.out.println(o instanceof Person);//true System.out.println(o instanceof Object);//true //编译报错 System.out.println(o instanceof Teacher); //编译报错 System.out.println(o instanceof String);

System.out.println(x instanceof Y); 该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有"子父类关"系就编译通过, 没有子父类关系就是编译报错.

父类引用可以指向子类对象，子类引用不能指向父类对象。
把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。如Father father = new Son();
把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）father；其中father前面的（Son）必须添加，进行强制转换。
upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效
向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

static修饰符

在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。

静态变量属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问.

静态变量对于类而言在内存中只有一个,能被类的所有实例所共享。实例变量对于类的每个实例都有一份,它们之间互不影响。

在加载类的过程中为静态变量分配内存,实例变量在创建对象时分配内存，所以静态变量可以使用类名来

直接访问,而不需要使用对象来访问。

在类中,使用static修饰的成员方法,就是静态方法,反之为非静态方法

静态方法数属于类的,"可以"使用类名来调用,非静态方法是属于对象的,"必须"使用对象来调用.

静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态方法

注意:this和super在类中属于非静态的变量.(静态方法中不能使用)

非静态方法"可以"直接访问类中的非静态变量和非静态方法,也"可以"直接访问类中的静态变量和静态方法

父类的静态方法可以被子类继承,但是不能被子类重写

父类的非静态方法不能被子类重写为静态方法；

代码块和静态代码块

public class Person { { //代码块(匿名代码块) }static{ //静态代码块 } }

因为没有名字,在程序并不能主动调用这些代码块。

匿名代码块是在创建对象的时候自动执行的,并且在构造器执行之前。同时匿名代码块在每次创建对象的时候都会自动执行.

静态代码块是在类加载完成之后就自动执行,并且只执行一次.

注:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次

public class Person { { System.out.println("匿名代码块"); }static{ System.out.println("静态代码块"); }public Person(){ System.out.println("构造器"); } }main: Student s1 = new Student(); Student s2 = new Student(); Student s3 = new Student(); //输出静态代码块 匿名代码块 构造器 匿名代码块 构造器 匿名代码块 构造器

【匿名代码块和静态代码块的作用】

匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块使用的并不多。

静态代码块的作用是给类中的静态成员变量初始化赋值。

在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才指向,但是静态变量可以不创建对象而直接使用类名来访问.

创建和初始化对象的过程

Student s = new Student();

【Student类之前没有进行类加载】

类加载,同时初始化类中静态的属性
执行静态代码块
分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
调用Student的父类构造器
对Student中的属性进行显示赋值(如果有的话)
执行匿名代码块
执行构造器
返回内存地址

注:子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候

public class Person{ private String name = "zs"; public Person() { System.out.println("Person构造器"); print(); }public void print(){System.out.println("Person print方法: name = "+name); } }public class Student extends Person{ private String name = "tom"; { System.out.println("Student匿名代码块"); }static{ System.out.println("Student静态代码块"); }public Student(){ System.out.println("Student构造器"); }public void print(){ System.out.println("student print方法: name = "+name); }public static void main(String[] args) { new Student(); } }//输出： Student静态代码块 Person构造器 student print方法: name = null Student匿名代码块 Student构造器 Student s = new Student(); Student类之前已经进行了类加载 1.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null) 2.调用Student的父类构造器 3.对Student中的属性进行显示赋值(如果有的话) 4.执行匿名代码块 5.执行构造器 6.返回内存地址

静态导入

静态导包就是java包的静态导入，用import static代替import静态导入包是JDK1.5中的新特性。

好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…)，在使用时直接print(…)就可以了。

final修饰符

用final修饰的类不能被继承,没有子类。

用final修饰的方法可以被继承,但是不能被子类的重写。

用final修饰的变量表示常量,只能被赋一次值.其实使用final修饰的变量也就成了常量了,因为值不会再变了。

abstract修饰符

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

public abstract class Action{ public abstract void doSomething(); }public void doSomething(){...}

对于这个普通方法来讲:

"public void doSomething()"这部分是方法的声明

"{...}"这部分是方法的实现,如果大括号中什么都没写,就叫方法的空实现

声明类的同时,加上abstract修饰符就是抽象类

声明方法的时候,加上abstract修饰符,并且去掉方法的大口号,同时结尾加上分号,该方法就是抽象方法。

抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。

抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

注:子类继承抽象类后,需要实现抽象类中没有实现的抽象方法,否则这个子类也要声明为抽象类。

子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

思考1 : 抽象类不能new对象,那么抽象类中有没有构造器?

抽象类是不能被实例化,抽象类的目的就是为实现多态中的共同点,抽象类的构造器会在子类实例化时调用,因此它也是用来实现多态中的共同点构造，不建议这样使用！

接口的本质

普通类：只有具体实现

抽象类：具体实现和规范(抽象方法) 都有！

接口：只有规范！

【为什么需要接口?接口和抽象类的区别?】

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。
从接口的实现者角度看，接口定义了可以向外部提供的服务。
从接口的调用者角度看，接口定义了实现者能提供那些服务。
接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。

【接口的本质探讨】

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象

接口与抽象类的区别

抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口。

声明类的关键字是class,声明接口的关键字是interface。

抽象类是用来被继承的,java中的类是单继承。

类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态

一个父类的引用,可以指向这个父类的任意子类对象

接口是用来被类实现的,java中的接口可以被多实现。

类A实现接口B、C、D、E..,那么类A的对象就属于B、C、D、E等类型了,可以使用多态

一个接口的引用,可以指向这个接口的任意实现类对象

接口中可以不写任何方法,但如果写方法了,该方法必须是抽象方法

public interface Action{ public abstract void run(); //默认就是public abstract修饰的 void test(); public void go(); }

接口中可以不写任何属性,但如果写属性了,该属性必须是public static fifinal修饰的静态常量。

注:可以直接使用接口名访问其属性。因为是public static修饰的

注:声明的同时就必须赋值.(因为接口中不能编写静态代码块)

public interface Action{ public static final String NAME = "tom"; //默认就是public static final修饰的 int AGE = 20; }main: System.out.println(Action.NAME); System.out.println(Action.AGE);

一个类可以实现多个接口

public class Student implements A,B,C,D{ //Student需要实现接口A B C D中所有的抽象方法 //否则Student类就要声明为抽象类,因为有抽象方法没实现 }main: A s1 = new Student(); B s2 = new Student(); C s3 = new Student(); D s4 = new Student();

注:

s1只能调用接口A中声明的方法以及Object中的方法

s2只能调用接口B中声明的方法以及Object中的方法

s3只能调用接口C中声明的方法以及Object中的方法

s4只能调用接口D中声明的方法以及Object中的方法

注:必要时可以类型强制转换

例如 : 接口A 中有test() ，接口B 中有run()

A s1 = new Student(); s1.test(); B s2 = new Student(); s2.run(); if(s1 instanceof B){ ((B)s1).run(); }

一个接口可以继承多个父接口

public interface A{ public void testA(); }public interface B{ public void testB(); }//接口C把接口A B中的方法都继承过来了 public interface C extends A,B{ public void testC(); }//Student相当于实现了A B C三个接口,需要实现所有的抽象方法 //Student的对象也就同时属于A类型 B类型 C类型 public class Student implements C{ public viod testA(){} public viod testB(){} public viod testC(){} }main: C o = new Student(); System.out.println(o instanceof A);//true System.out.println(o instanceof B);//true System.out.println(o instanceof C);//true System.out.println(o instanceof Student);//true System.out.println(o instanceof Object);//true System.out.println(o instanceof Teacher);//false //编译报错 System.out.println(o instanceof String);

接口的作用

接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建

【接口名】【对象名】= new 【实现接口的类】

这样用哪个类的对象就可以new哪个对象了，不需要改原来的代码。

假如我们两个类中都有个function()的方法，如果我用接口，那样我new a()；就是用a的方法，newb（）就是用b的方法

这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同

Java接口中的成员变量默认都是public,static,fifinal类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)
Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
Java接口中只能包含public,static,fifinal类型的成员变量和public,abstract类型的成员方法
接口中没有构造方法,不能被实例化
一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
Java接口必须通过类来实现它的抽象方法
当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类
不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.

interface SwimInterface{ void swim(); }class Fish{ int fins=4; }class Duck { int leg=2; void egg(){}; }class Goldfish extends Fish implements SwimInterface { @Override public void swim() { System.out.println("Goldfish can swim "); } }class SmallDuck extends Duck implements SwimInterface { public void egg(){ System.out.println("SmallDuck can lay eggs "); }@Override public void swim() { System.out.println("SmallDuck can swim "); } }public class InterfaceDemo { public static void main(String[] args) { Goldfish goldfish=new Goldfish(); goldfish.swim(); SmallDuck smallDuck= new SmallDuck(); smallDuck.swim(); smallDuck.egg(); } }

内部类概述

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

内部类不是在一个java源文件中编写俩个平行的俩个类,而是在一个类的内部再定义另外一个类。

成员内部类（实例内部类、非静态内部类）

成员内部类中不能写静态属性和方法

【定义一个内部类】

//在A类中申明了一个B类，此B类就在A的内部，并且在成员变量的位置上，所以就称为成员内部类 public class Outer { private int id; public void out(){ System.out.println("这是外部类方法"); }class Inner{ public void in(){ System.out.println("这是内部类方法"); } } }

【实例化内部类】

实例化内部类，首先需要实例化外部类，通过外部类去调用内部类

public class Outer { private int id; public void out(){ System.out.println("这是外部类方法"); }class Inner{ public void in(){ System.out.println("这是内部类方法"); } } }public class Test{ public static void main(String[] args) { //实例化成员内部类分两步 //1、实例化外部类 Outer outObject = new Outer(); //2、通过外部类调用内部类 Outer.Inner inObject = outObject.new Inner(); //测试，调用内部类中的方法 inObject.in();//打印：这是内部类方法 } }

【成员内部类能干什么？】

1. 访问外部类的所有属性(这里的属性包括私有的成员变量，方法)

public class Outer { private int id; public void out(){ System.out.println("这是外部类方法"); }class Inner{ public void in(){ System.out.println("这是内部类方法"); }//内部类访问外部类私有的成员变量 public void useId(){ System.out.println(id+3);。 }//内部类访问外部类的方法 public void useOut(){ out(); } } }public class Test{ public static void main(String[] args) { //实例化成员内部类分两步 //1、实例化外部类 Outer outObject = new Outer(); //2、通过外部类调用内部类 Outer.Inner inObject = outObject.new Inner(); //测试 inObject.useId();//打印3，因为id初始化值为0，0+3就为3，其中在内部类就使用了 外部类的私有成员变量id。 inObject.useOut();//打印：这是外部类方法 } }

如果内部类中的变量名和外部类的成员变量名一样，要通过创建外部类对象 "."属性来访问外部类属性，通过this.属性访问内部类成员属性

public class Outer { private int id;//默认初始化0 public void out(){ System.out.println("这是外部类方法"); } class Inner{ private int id=8; //这个id跟外部类的属性id名称一样。 public void in(){ System.out.println("这是内部类方法"); }public void test(){ System.out.println(id);//输出8，内部类中的变量会暂时将外部类的成员 变量给隐藏 //如何调用外部类的成员变量呢？通过Outer.this，想要知道为什么能通过这个 来调用，就得明白下面这个原理 //想实例化内部类对象，就必须通过外部类对象，当外部类对象来new出内部类对 象时，会 //把自己(外部类对象)的引用传到了内部类中，所以内部类就可以通过 Outer.this来访问外部类的属性和方法，到这里，你也就可以知道为什么内部类可以访问外部类 的属性和方法，这里由于有两个相同的 属性名称，所以需要显示的用Outer.this来调用外部类的属性，平常如果属性名 不重复，那么我们在内部类中调用外部类的属性和方法时，前面就隐式的调用了Outer.this。 System.out.println(Outer.this.id);//输出外部类的属性id。也 就是输出0 } } }

借助成员内部类，来总结内部类(包括4种内部类)的通用用法：

要想访问内部类中的内容，必须通过外部类对象来实例化内部类。
能够访问外部类所有的属性和方法，原理就是在通过外部类对象实例化内部类对象时，外部类对象把自己的引用传进了内部类，使内部类可以用通过Outer.this去调用外部类的属性和方法，

一般都是隐式调用了，但是当内部类中有属性或者方法名和外部类中的属性或方法名相同的时候，就需要通过显式调用Outer.this了。

public class MemberInnerClassTest { private String name; private static int age; public void run(){} public static void go(){} public class MemberInnerClass{ private String name; //内部类访问外部类 public void test(String name){ System.out.println(name); System.out.println(this.name); System.out.println(MemberInnerClassTest.this.name); System.out.println(MemberInnerClassTest.age); MemberInnerClassTest.this.run(); MemberInnerClassTest.go(); } } //外部类访问成员内部类 //成员内部类的对象要 依赖于外部类的对象的存在 public void test(){ //MemberInnerClass mic = MemberInnerClassTest.this.new MemberInnerClass(); //MemberInnerClass mic = this.new MemberInnerClass(); MemberInnerClass mic = new MemberInnerClass(); mic.name = "tom"; mic.test("hua"); }public static void main(String[] args) { //MemberInnerClass mic = new MemberInnerClass();这个是不行的，this是动 态的。 //所以要使用要先创建外部类对象，才能使用 MemberInnerClassTest out = new MemberInnerClassTest(); MemberInnerClass mic = out.new MemberInnerClass(); //如果内部类是private,则不能访问，只能铜鼓内部方法来调用内部类 mic.name="jik"; mic.test("kkk"); } }

静态内部类

public class StaticInnerClassTest { private String name; private static int age; public void run(){} public static void go(){} //外部类访问静态内部类 public void test(){ StaticInnerClass sic = new StaticInnerClass(); //静态的内部类不需要依赖 外部类，所以不用this sic.name = "tom"; sic.test1("jack"); StaticInnerClass.age=10; StaticInnerClass.test2("xixi"); }private static class StaticInnerClass{ private String name; private static int age; public void test1(String name){ System.out.println(name); System.out.println(this.name); System.out.println(StaticInnerClass.age); System.out.println(StaticInnerClassTest.age); //System.out.println(StaticInnerClassTest.this.name);静态类不能访 问非静态属性 StaticInnerClassTest.go(); //StaticInnerClassTest.this.run();静态类不能访问非静态方法 }public static void test2(String name){ //只能访问自己和外部类的静态属性和方法 System.out.println(name); //System.out.println(this.name);静态方法里面连自己类的非静态属性都不能 访问 System.out.println(StaticInnerClass.age); System.out.println(StaticInnerClassTest.age); //System.out.println(StaticInnerClassTest.this.name);静态方法不能 访问非静态属性 StaticInnerClassTest.go(); //StaticInnerClassTest.this.run();静态方法不能访问非静态方法 } } }

注意：

我们上面说的内部类能够调用外部类的方法和属性，在静态内部类中就行了，因为静态内部类没有了指向外部类对象的引用。除非外部类中的方法或者属性也是静态的。这就回归到了static关键字的用法。
静态内部类能够直接被外部类给实例化，不需要使用外部类对象
```
Outer.Inner inner = new Outer.Inner(); 
```
静态内部类中可以声明静态方法和静态变量，但是非静态内部类中就不可以声明静态方法和静态变量

局部内部类

局部内部类是在一个方法内部声明的一个类

局部内部类中可以访问外部类的成员变量及方法

局部内部类中如果要访问该内部类所在方法中的局部变量,那么这个局部变量就必须是final修饰的

public class Outer { private int id; //在method01方法中有一个Inner内部类，这个内部类就称为局部内部类 public void method01(){class Inner{ public void in(){ System.out.println("这是局部内部类"); } } } }

匿名内部类

什么是匿名对象？如果一个对象只要使用一次，那么我们就是需要new Object().method()。就可以了，而不需要给这个实例保存到该类型变量中去。这就是匿名对象。

public class Test { public static void main(String[] args) { //讲new出来的Apple实例赋给apple变量保存起来，但是我们只需要用一次，就可以这样写 Apple apple = new Apple(); apple.eat(); //这种就叫做匿名对象的使用，不把实例保存到变量中。 new Apple().eat(); } }class Apple{ public void eat(){ System.out.println("我要被吃了"); } }

匿名内部类需要依托于其他类或者接口来创建
如果依托的是类,那么创建出来的匿名内部类就默认是这个类的子类
如果依托的是接口,那么创建出来的匿名内部类就默认是这个接口的实现类。
匿名内部类的声明必须是在使用new关键字的时候
匿名内部类的声明及创建对象必须一气呵成,并且之后不能反复使用,因为没有名字

A是一个类(普通类、抽象类都可以)，依托于A类创建一个匿名内部类对象

main: A a = new A(){ //实现A中的抽象方法 //或者重写A中的普通方法 };注:这个大括号里面其实就是这个内部类的代码,只不过是声明该内部类的同时就是要new创建了其对象, 并且不能反复使用,因为没有名字。 例如: B是一个接口，依托于B接口创建一个匿名内部类对象 B b = new B(){ //实现B中的抽象方法 };

匿名内部类除了依托的类或接口之外,不能指定继承或者实现其他类或接口,同时也不能被其他类所继承,因为没有名字。
匿名内部中,我们不能写出其构造器,因为没有名字。
匿名内部中,除了重写上面的方法外,一般不会再写其他独有的方法,因为从外部不能直接调用到。(间接是调用到的)

public interface Work{ void doWork(); }public class AnonymousOutterClass{ private String name; private static int age; public void say(){} public static void go(){} public void test(){ final int i = 90; Work w = new Work(){ public void doWork(){ System.out.println(AnonymousOutterClass.this.name); System.out.println(AnonymousOutterClass.age); AnonymousOutterClass.this.say(); AnonymousOutterClass.go(); System.out.println(i); } };w.doWork(); } }