一、继承

关键字：extends
1、定义：
子类继承父类，就会继承父类所有非私有属性。
所以在设计父类与子类时，
将子类共有的特点（属性）和行为（方法）抽离出来定义为父类。
将子类特有的特点（属性）和行为（方法）定义在子类中，其他的则使用父类中的。
2、方法的重写：
（1）重载（overload）：
条件： 方法名相同，参数列表不相同，与返回值类型与访问修饰符无关。

（2）重写（override)：
如果子类中有和父类相同的方法，那么就会调用子类的方法，父类的方法就会被覆盖。
条件： 方法名、参数列表以及返回值类型相同，访问修饰符不能比父类的更严格。
3、继承的初始化顺序
1、先初始化父类，再初始化子类（先加载父类，方便子类去使用）
初始化，也就是执行构造方法。
2、先执行初始化对象中属性，再执行构造方法中的初始化。
综上所述，当我们创建一个子类对象时，
在代码中的体现（引入super关键字）

package Test;

public class Person {
String name;
int age;
public Person() {
System.out.println("这是父类无参构造");
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student extends Person{
String id;
public Student() {
super();
System.out.println("这是子类无参构造");
}
public Student(String id) {
super();
System.out.println("这是子类有参构造");
}
//将所有属性初始化的有参构造
public Student(String name,int age,String id) {
super(name,age);
this.id = id;
}
}

归纳：（super）
1、super代表父类对象。
访问父类属性： super.name;
访问父类方法： super.eat();
2、在子类构造器中（有参or无参），都会默认在第一行添加super()，意思是先创建父类对象。且必须写在子类构造器中的第一行。

** 4、注意点：**
1、Java只支持单继承，一个类只能继承一个子类。
2、Java中可以多重继承，继承具有传递性。

5、补充：（访问修饰符）
√/×表示属性或者方法能否被访问。

在不同包下需要导包。

二、多态

1、使用前提： 实现多态首先需要继承同一个父类。
2、概念： 一种类型的多种形态（同种类型以不同的形态展现出来）
3、在代码中的表现：
Cat与Dog共同继承自Animal类
Animal类：

public class Animal {
String name;
int age;

public void eat() {
System.out.println("动物吃东西");
}
}

Cat类：

public class Cat extends Animal{
String name = "小花";
public void eat() {
System.out.println("小花吃鱼");
}
public void say() {
System.out.println("喵喵喵~");
}
}

Dog类：

public class Dog extends Animal{

}

（1）运用多态的思想创建对象：

Animal cat1 = new Cat();
Animal dog1 = new Dog();

分析：
cat1、dog1都是Animal类型的，但cat1是猫形态的动物，dog1是狗形态的动物。

（2）强转的运用：

public class Main {
public static void main(String[] args) {
Animal cat1 = new Cat();
Animal dog1 = new Dog();Cat cat2 = (Cat)cat1;
//注意：
System.out.println(cat1);//Test.Cat@15db9742
System.out.println(cat2);//Test.Cat@15db9742
}
}

（3）使用多态时调用属性/方法
调用属性时， 看对象的类型，对象的类型是哪个，调用的就是哪个类中的属性。（要考虑到强转）

public class Main {
public static void main(String[] args) {
Animal cat1 = new Cat();
Animal dog1 = new Dog();Cat cat2 = (Cat)cat1;
//注意：
System.out.println(cat1.name);//null	Animal类中的name
System.out.println(cat2.name);//小花	Cat类中的name
}
}

*调用方法时，*如果子类覆盖了父类中的方法，调用的都是子类中的方法。

public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
Animal cat1 = new Cat();

cat.eat();//小花吃鱼
cat.eat();//小花吃鱼
}
}

注意： 能点出什么，要看类型中有什么。

public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
Animal cat1 = new Cat();

//cat1.say(); //Animal类型中没有say()方法
}
}

（4）向上转型与向下转型
向上转型，将子类对象转为父类对象。
向下转型，将父类对象转为子类对象。
举例：
编译器不会报错，但是运行后会报错，
错误类型：java.lang.ClassCastException: 类转换 异常

Cat cat2 = (Cat)new Animal();

三、封装

封装的思想：将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常是对客户隐藏其细节的。
例如，我们不需要对电脑的内部设置进行了解，当你要输入文字时，点击键盘上的对应键就可以了。
此处的封装应指，在设计类的时候，将所有的属性私有化（用private修饰），即只能在本类中直接范围，如果在别的类需要访问时，就要通过本类提供的特定getXXX和setXXX方法进行访问。

四、一些相关小知识点

1、instanceof关键字

（1）作用： 用于判断前面的对象是否是后面的类或者其子类，实现类的实例。
（2）注意： 使用instanceof关键字做判断时， instanceof 操作符的左右操作数必须有继承或实现关系
“前面是对象，后面是类”

2、static与final

static

静态的，共享的。可用于修饰属性、方法以及代码块。
注意点：
1、被static修饰的资源，可以直接用类名调用，无需创建对象。
2、静态资源只有一份，所有的对象都共用这一个资源，如果一个对象修改了资源，那么其他对象获取到的就是修改后的资源了。
3、静态资源只加载一次。
4、静态资源不依赖与对象，依赖于类。
静态资源在类加载的时候就被加载进来了，优先于对象的存在。
静态方法不能直接调用非静态的东西（因为非静态的资源需要对象调用，但是静态方法加载时对象还不存在）。
静态方法可以直接调用静态的东西。
子类和父类各类代码块的执行顺序
结论：父类静态代码块-子类静态代码块-父类代码块-父类构造方法-子类代码块-子类构造方法

代码演示：

public class Father {
static {
System.out.println("父类静态代码块");
}
{
System.out.println("父类代码块");
}
public Father() {
System.out.println("父类构造方法");
}

public static void main(String[] args) {
Son son1 = new Son();
System.out.println();
Son son2 = new Son();//注意：静态资源只加载一次
}
}
class Son extends Father{
static {
System.out.println("子类静态代码块");
}
{
System.out.println("子类代码块");
}
public Son() {
System.out.println("子类构造方法");
}
}

final

表示最终的，不能更改的。
注意点：
（1）修饰类时，表示为终类，即此类不能被继承。
（2）修饰方法时，此方法不能被覆盖，但是可以被子类继承。
（3）修饰属性时，必须手动给初始值，并且给定之后不能被更改。（初始值可以在声明时给，也可以在构造器中给）

static与final的联合使用

用于定义常量。
比如：定义一个SCREEN_WIDTH常量

public static final int SCREEN_WIDTH = 600;
public final static int SCREEN_WIDTH = 600;

注意： 常量的命名规范：字母都大写，用下划线连接多个单词