1：将复杂的事情简单化。

　　2：面向对象将以前的过程中的执行者，变成了指挥者。

　　3：面向对象这种思想是符合现在人们思考习惯的一种思想。

类

主函数

主函数的存在，仅为该类是否需要独立运行，如果不需要，主函数是不用定义的。

成员变量和局部变量

1：成员变量直接定义在类中。

局部变量定义在方法中，参数上，语句中。

2：成员变量在这个类中有效。

局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。

3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。

局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

构造函数

是给与之对应的对象进行初始化，它具有针对性，函数中的一种。

1：该函数的名称和所在类的名称相同。

2：不要定义返回值类型。（有返回值就是普通方法了）

3：该函数没有具体的返回值。

创建对象的过程

1：先将硬盘上指定位置的Person.class文件加载进内存。

2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。

3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new

4：在该实体空间中进行属性的空间分配，并进行了默认初始化，对属性进行显示初始化。

5：进行实体的构造代码块初始化。

6：调用该实体对应的构造函数，进行构造函数初始化。（）

7：将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)

继承

作用：

1：提高了代码的复用性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

特点：

1 支持多重继承：A继承B B继承C C继承D。

2 子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值（如果想要调用父类中的属性值，需要使用一个关键字：super）。

3 重写：当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。

4 子类构造函数运行时，先运行了父类的构造函数。（原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super();）

问题

为什么不支持多继承？

因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。

super()和this()是否可以同时出现的构造函数中？

两个语句只能有一个定义在第一行，所以只能出现其中一个。

super()或者this():为什么一定要定义在第一行？

因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。其实是不然会初始化多次。

PS

如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

继承的一个弊端：打破了封装性。因为属性或方法的访问修饰符被修改。这时如何解决问题呢？介绍一个关键字，final:最终。

重写

子类重写父类的方法

1. 方法的参数签名和返回值类型必须相同，访问控制修饰符可以不同，但是子类方法不能缩小父类方法的访问权限。

2. 子类方法抛出的异常必须和父类方法抛出的异常相同，或者是父类方法抛出的异常类的子类。

3. 父类的静态方法是不能被子类覆盖为非静态方法，非静态方法不能被覆盖为静态方法。

4. 子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法。区别：运行时，JVM把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。

5. 父类的私有方法不能被覆盖

6. 父类的非抽象方法可以被覆盖为抽象方法 即 重载 （从父类中继承的方法，和自己的方法名一样，但参数不一致，是重载）。

重载

 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

1 被重载的方法必须改变参数列表(参数个数、类型、顺序不一样)；

2 被重载的方法可以改变返回类型；

3 被重载的方法可以改变访问修饰符；

4 被重载的方法可以声明新的或更广的检查异常；

5 方法能够在同一个类中或者在一个子类中被重载。

如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系

方法签名：指的是方法名+方法参数(包括参数类型，顺序，个数)，注意，不包括方法返回值。

this 和 super

this

代表当前对象，就是所在函数所属对象的引用。

1 this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；

2 this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

super

我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

1. 在类的构造方法中，通过super语句调用这个类的父类的构造方法。在构造方法中，super语句必须作为构造方法的第一条语句。

2. 在子类中访问父类的被屏蔽的方法和属性

3. 只能在构造方法或实例方法内使用super关键字。 super关键字与类的特定实例相关

多态

1. 对于一个引用类型的变量，Java编译器按照它声明的类型来处理。

Base base = new Sub();

base.subMethod(); // 编译出错，Base基类，Sub子类，编译器认为base是Base类型的引用变量，Base类没有subMethod()方法。这样子，就必须使用强制转换。(Sub)(base).subMethod();

2. 对于一个引用类型的变量，运行时JVM按照它实际引用的对象来处理。

Base base = new Base();

Sub sub = (Sub)base; // 编译通过，但是运行时抛出ClassCastException

在运行时，子类的引用类型变量可以转换为父类的引用类型，而相反的过程却不可以。

假定可以，即上边两行代码运行正常，那么sub.subMethod(); 执行时，JVM将找不到subMethod。sub实际引用的是Base类的实例。

3. 在运行时环境中，通过引用类型变量来访问所引用对象的方法和属性时，JVM采用以下的绑定规则。

①实例方法与引用变量实际引用的对象的方法绑定，即动态绑定。

②静态方法与引用变量所声明的类型的方法绑定，即静态绑定。 编译阶段即绑定完成。

③成员变量(静态变量和实例变量) 与引用类型所声明的类型的成员变量绑定。静态绑定。

接口

接口中包含的成员，最常见的有全局常量、抽象方法。

1. 接口中的成员变量默认（只能）都是public、static、final类型的，必须被显式初始化

2. 接口中的方法默认（只能）都是public、abstract类型的。

3. 接口没有构造方法，不能被实例化，在接口中定义构造方法是非法的。

4. 一个接口不能实现另一个接口，但它可以继承多个其他接口。interface C extends A, B{} // A和B都是接口

5. 当类实现某个接口时，它必须实现接口中所有的抽象方法，否则这个类必须被定义为抽象类。

6. 接口中没有方法体

抽象类与接口：

抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。抽象类使用的是 is a 关系。

接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。接口使用的 like a 关系。接口中的成员修饰符是固定的。全都是public的。

修饰符

访问权限

private， 只能在同一个类中访问

default，只能在同一个类，同一个包中访问

protected，可以在统一各类，同一个包，子类(子类可以不在同一个包中)访问

public，不限制访问

类可用的修饰符： public（或者default）内部类除外、abstract、final

static

用于修饰成员(成员变量和成员函数）。

特点

1. 静态变量在内存中只有一个拷贝，在类的所有实例中共享。

2. 在静态方法中不能直接访问实例方法和实例变量（非静态成员）。

3. 在静态方法中不能使用this和super关键字。

4. 静态方法不能被abstract修饰

5. 静态方法和静态变量都可以通过类名直接被访问。

6. 当类被加载时，静态代码块只被执行一次。类中不同的静态代码块按它们在类中出现的顺序被依次执行

成员变量和静态变量的区别

1，成员变量所属于对象，所以也称为实例变量。

静态变量所属于类，所以也称为类变量。

2，成员变量存在于堆内存中。

静态变量存在于方法区中。

3，成员变量随着对象创建而存在，随着对象被回收而消失。

静态变量随着类的加载而存在，随着类的消失而消失。

4，成员变量只能被对象所调用。

静态变量可以被对象调用，也可以被类名调用。

静态代码块

就是一个有静态关键字标示的一个代码块区域，定义在类中。

作用：可以完成类的初始化，静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。如果和主函数在同一类中，优先于主函数执行。

构造代码块

在java类中使用{}声明的代码块（和静态代码块的区别是少了static关键字）:

构造代码块在创建对象时被调用，每次创建对象都会调用一次，但是优先于构造函数执行（依托于构造函数）。

普通代码块

普通代码块：构造代码块是在类中定义的，而普通代码块是在方法体中定义的。且普通代码块的执行顺序和书写顺序一致。

执行顺序：静态代码块 —>构造代码块 –> 构造函数–>普通代码块；

final

1：被final修饰的类是一个最终类，不可以被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。

2：被final修饰的方法是一个最终方法，不可以被覆盖。

3：被final修饰的变量是一个常量，只能赋值一次，必须被显式初始化。

4：private修饰的方法默认为是final方法，因而不能被子类的方法覆盖。

另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。

abstract

1. 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类。

2. 抽象类中可以有非抽象的构造方法，创建子类的实例时可能会调用这些构造方法。

3. 抽象类不能被实例化。因为抽象类可能含有没有方法体的抽象方法

4. 没有抽象构造方法，没有抽象静态、抽象私有方法。abstrac 和 statict、private 不能连用

5. 抽象类及抽象方法不能被final修饰符修饰。