面向对象：三个特征：封装，继承，多态。
类和对象的关系：类就是：对现实生活中事物的描述。
对象：就是这类事物，实实在在存在个体。
属性对应是类中变量，行为对应的类中的函数(方法)。
其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。
成员变量和局部变量：
作用范围：成员变量作用于整个类中。
局部变量变量作用于函数中，或者语句中。
在内存中的位置：成员变量：在堆内存中，因为对象的存在，才在内存中存在。
局部变量：存在栈内存中。
this：就代表本类的对象，到底代表哪一个呢？
this代表它所在函数所属对象的引用。
简单说：哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
但凡本类功能内部使用了了本类对象，都用this表示。
对象一建立就会调用与之对应的构造函数。
构造函数的作用：可以用于给对象进行初始化。
构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。
构造函数和一般函数在写法上有不同。在运行上也有不同。
构造函数是在对象一建立就运行。给对象初始化。
而一般方法是对象调用才执行，给是对象添加对象具备的功能。
一个对象建立，构造函数只运行一次。
而一般方法可以被该对象调用多次。
什么时候定义构造函数？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造代码块。
作用：给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
构造代码快中定义的是不同对象共性的初始化内容。
匿名对象使用方式：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员调用，必须给这个对象起个名字。
匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
静态：static。
用法：是一个修饰符，用于修饰成员(成员变量，成员函数).
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，
还可以直接被类名调用。类名.静态成员。
static特点：
1，随着类的加载而加载。
也就说：静态会随着类的消失而消失。说明它的生命周期最长。
2，优先于的对象存在
明确一点：静态是先存在。对象是后存在的。
3，被所有对象所共享
4，可以直接被类名所调用。
静态使用注意事项：
1，静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2，静态方法中不可以定义this，super关键字。
因为静态优先于对象存在。所以静态方法中不可以出现this。
3，主函数是静态的。
静态有利有弊
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊端：生命周期过长。
访问出现局限性。(静态虽好，只能访问静态。)
什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数呢？
当功能内部没有访问到肺静态数据(对象的特有数据)，那么该功能可以定义成静态的。
静态代码块。
格式：
static
{
静态代码块中的执行语句。
}
特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。
继承：
特点：1，提高了代码的复用性。
2，让类与类之间产生关系，是多态性的前提。
Java中的继承：1，java只支持单继承，不支持多继承。原因：因为继承了多个父类如果有相同方法时，子类对象不确定运行哪一个。
2，Java还支持多层继承。A-->B--->C 可以形成继承体系。想要使用体系功能，"查阅父类功能，建立子类对象调用功能。"
注解：父类的由来其实是由事物中的共性内容不断向上抽取而来的。所以父类中定义的是该体系中的最基本，最共性功能。
继承出现后，代码上也有一些特点：
1，变量。
当子父类中定义了相同的名称的成员变量，
子类要使用父类中的同名变量时，需要使用关键字super来区分。
一般不会出现这种情况，因为父类中有了，子类不需要定义。
而且父类定义时，一般变量都私有化。
2，函数。
子类可以直接访问父类中非私有的成员函数。
特殊情况：当子类中定义了与父类一模一样的方法时，会发生覆盖操作。大多指的是非静态方法。
最终会运行子类的方法，父类相当于被覆盖了。
函数的另一个特性：覆盖（重写，复写）。
什么时候用啊？
当父类的功能要被修改时，不建议修改源码。
只要通过一个类继承原有类，定义一个新的升级后的功能即可。
但是功能是相同的，只是实现方法改变。这是子类可以沿袭父类中的功能定义，并重写功能内容。这就是覆盖。
覆盖注意事项：
1，子类覆盖父类时，必须权限要大于等于父类权限。
2，静态不能覆盖非静态。
3，构造函数。
构造函数可以本类进行对象初始化，也可以给子类对象进行初始化。
子类对象初始化过程：
子类中的所有构造方法都会访问父类中空参数的构造函数，
因为每一个构造函数的第一行，都有一句隐式的super语句。
为什么要有这条语句？
因为子类会获取到父类中的数据，必须要先明确父类对数据的初始化过程。
当父类中没有空参数构造函数时，子类构造函数必须通过super句来明确要访问的父类中指定的构造函数。
子类构造函数也可以通过this语句访问本类中的构造函数。
但是子类中肯定至少有一个构造函数会访问父类。
抽象类：其实就是在分析事物时，事物中的功能有些是不明确的内容的。这些不明确内容就是抽象的。可以通过抽象函数来描述。
抽象函数一定要定义在抽象类中，因为，抽象函数所在类，也必须被抽象标识。
写法特点：
1，抽象函数只对函数进行声明，没有函数主体。
2，抽象类和抽象函数都需要用abstract修饰。
3，抽象类不可以进行实例化。
4，想要使用抽象功能，必须通过子类覆盖了父类中所有的抽象方法后，才可以对子类实例化。如果只覆盖了部分抽象方法，那么子 类还是一个抽象类。
也可以理解为：抽象类是一个父类，是不断向上抽取而来的，在抽取过程中，只抽取了方法声明，但没有抽取方法实现。
抽象类和一般类差不多。
区别：抽象类可以定义抽象方法。抽象类不可以建立对象。
其实抽象类一样用于描述事物，既可以定义抽象方法，也可以定义非抽象方法。
接口：初期理解：接口看上去是一个特殊的抽象类。里面存的都是抽象方法。
可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的方式来表示。用interface来定义接口。
接口的特点：
1. 接口中常见定义：常量，抽象方法。
2. 接口中的成员都有固定修饰符。
a) 常量：public static final
b) 方法：public abstract
3. 接口中的成员都是public的。
4. 接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对象中的抽象方法全都覆盖后子类才可以实例化。否则子类是一个抽象类。
5. 接口与接口之间存在多继承。一个接口可以同时继承多个接口。
1. 接口是对外暴露的规则。
2. 接口是程序的功能扩展。
3. 接口可以用来多实现。
4. 类与接口之间是实现关系，而且类可以集成一个类的同时实现多个接口。
5. 接口与接口之间可以有继承关系。
格式 ：1，通过interface来定义。
2，接口中常见成员：常量，抽象方法。而且这些成员都有固定的修饰符。
常量：public static final
方法：public abstract
3，接口中的成员都是共有的。
4，一个类可以对接口进行多实现，也弥补了多继承带来的安全隐患，所以java对多继承进行了改良。用多实现方法来体现多继承的特性。
5，一个类可以继承一个类的同时，实现多个接口。
6，接口与接口之间是继承关系，而且可以多继承。
应用特点：
1，接口是对外暴露的规则。
2，接口是功能的扩展。
3，接口的出现降低了耦合性。
抽象类和接口异同：
相同：
1，都可以在内部定义抽象方法。
2，通常都在顶层。
3，都不可以实例化，都需要子类来实现。
不同点：
1，抽象类中可以定义抽象方法和非抽象方法，而接口中只能定义抽象方法。
2，接口的出现可以多实现。抽象类只能单继承。也就是说：接口的出现避免了单继承的局限性。
3，继承和实现的关系不一致。继承：is a，实现：like a
多态：
一，表现：
父类或者接口的引用指向了或者接收了自己的子类对象。
某一种事物的多种存在形态。
体现：父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。
前提：必须类与类之间有关系，要么继承要么实现。通常还有一个前提，存在子类覆盖父类的方法。
好处：多态的出现大大的提高了程序的扩展性。
弊端：提高了扩展性但是只能使用父类的引用访问父类中的成员。
注意事项（代码中的特点）：
在多态中【非静态成员函数】的特点：在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，否则失败。在运行期参阅对象所属的类中是否有调用的方法。
成员函数在多态调用时，编译看左边，运行看右边。
在多态中【成员变量】的特点：无论运行和编译期，都看左边。
在多态中【静态成员函数】的特点：无论编译和运行期都看左边。
二，前提：
1，类与类之间要有关系。继承，实现。
2，通常都会有覆盖。
三，好处：
预先定义的程序可以运行后期程序的内容。
增强了程序的扩展性。
四，弊端：
虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。
不能预先使用子类中定义的特有功能。
五，多态的注意事项：
在代码中。
对于成员函数：Fu f = new Zi(); f.method();
编译时期：看左边。
运行时期：看右边。
因为成员函数有一个覆盖操作。
对于非私有的实例变量，静态变量，静态方法。
编译和运行都看左边。
六，转型。
子类对象被父类引用：子类对象在向上转型。
将指向子类对象的父类应用转换成子类类型引用：向下转型。
七，应用
class MainBoard
{
public void run()
{
//主板运行;
}
public void usePCI(PCI p)//PCI p = new NetCard();
{
if(p!=null)
{
p.open();
p.close();
}
}
}
//为了提高主板功能的扩展性。
//定义了规则。让后期的出现的功能板块，只要覆盖该规则，就可以被这个主板使用。
interface PCI
{
void open();
void close();
}
class MainDemo
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
mb.run();
mb.usePCI(null);
mb.usePCI(new NetCard());
}
}
class NetCard implements PCI
{
public void open(){}
public void close(){}
}Object:是java中所有对象的直接或者间接的父类。
它里面的方法都所有对象都具备的。
常见方法：
boolean equals(Object obj):用于比较两个对象是否相同。
String toString(): 获取对象的字符串表现形式 类名@哈希值
getClass().getName()+"@"+Integer.toHexString(hashCode());
Class getClass():获取正在运行的对象所属的字节码文件的对象。也就是说如果Demo d = new Demo();
d.getClass():获取的就是d执行的对象所属的字节码文件Demo.class对象。
通常在自定义对象时，因为对象中都有自己特有的描述，
所以都会建立对象自身的特有比较方法，或者字符串表现形式。
也就是说，会覆盖Object中的方法。
内部类
将一个类定义在另一个类的里面，对里面那个类就成为内部类。
当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用内部事物的内容。
访问特点：
1. 内部类可以直接访问外部类中的成员，包括私有成员。之所以可以直接访问外部类的成员，是因为内部类中持有了一个外部类的引用。
》》访问外部类同名成员变量：Outer.this.属性名。
2. 而外部类要访问内部类中的成员必须要建立内部类的对象。
当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。格式：
Outer.Inner in = new Outer().new Inner();
当内部类在成员位置上，就可以被成员修饰符所修饰。比如private：将内部类在外部类中进行封装。Static：内部类就具备static的特性。当内部类被静态修饰后，只能直接访问外部类中的静态成员。出现了访问局限。
注意：当内部类中定义了静态成员，该内部类必须是静态的。
当外部类中的静态方法访问内部类时，内部类也必须是静态的。
内部类定义在局部时
1． 不可以被成员修饰符修饰。
2． 可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问他所在局部中的变量。只能访问被final修饰的局部变量。
匿名内部类：
1. 匿名内部类其实就是内部类的简写格式。
2. 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
3. 其实匿名内部类就是一个匿名子类对象。
4. 匿名内部类中定义的方法最好不要超过3个。
