一、继承
1、通过extends关键字可以实现类与类的继承
格式：class 子类名 extends 父类名{}
父类：基类、超类
子类：派生类
以人类、老师类、学生类举例
先创建一个人类
public class Person { //私有化成员变量 private String name; private int age; //set/get方法 public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } //有参数和无参数的构造 public Person(){} public Person(String name,int age){ this.name = name; this.age = age; } //吃饭和睡觉的方法 public void eat(){ System.out.println("民以食为天"); } public void sleep(){ System.out.println("睡觉也是个大事情"); } }分别创建学生类、老师类、继承人类 public class Student extends Person{ //如果父类的方法不满足子类的需求，子类可以写一个一摸一样的方法在自己的类体中，这样就实现了方法重写 public void eat(){ System.out.println("学生喜欢吃米饭"); } } public class Teacher extends Person{ //老师喜欢躺着睡，需要重写父类的sleep()方法 public void sleep(){ System.out.println("老师喜欢躺着睡"); } 继承的好处：A提高了代码的复用性 多个类相同的成员可以放到同一个类中 B:提高了代码的维护性 如果功能的代码需要修改，修改一处即可 C:让类与类之间产生了关系，是多态的前提 方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)： 1.必须存在继承关系 2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能
继承的特点：
A：Java只支持单继承，不支持多继承。
B：Java支持多层继承。
类的组成：
成员变量 、构造方法 、成员方法
继承间的成员变量关系：
A:名字不同，非常简单。 B:名字相同 首先在子类局部范围找 然后在子类成员范围找 最后在父类成员范围找(肯定不能访问到父类局部范围) 如果还是没有就报错。(不考虑父亲的父亲…) 就近原则。
super关键字：
super代表父类存储空间的标识(可以理解为父类对象)
A:成员变量 this.成员变量 本类的成员变量 super.成员变量 父类的成员变量 B:成员方法 this.成员方法() 本类的成员方法 super.成员方法()父类的成员方法
继承间构造方法的关系： 子类中所有的构造方法默认都会访问父类中空参数的构造方法(super()) 为什么呢? 因为子类会继承父类中的数据，可能还会使用父类的数据。 所以，子类初始化之前，一定要先完成父类数据的初始化。 每个子类的构造方法的第一行，有一条默认的语句: super(); 注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。 假如父类没有无参构造方法,该怎么办呢? A:调用父类的其他构造方法。带参构造。 怎么访问呢? super(...) 注意： super(…)或者this(….)必须出现在第一条语句上。 因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。 建议： 永远给出无参构造方法。
二、final关键字
在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。 即时是子类，也不允许。那么该怎么解决这个问题呢? java为了解决这样的问题就提供了一个关键字：final final: 最终的意思。它可以修饰类,方法,变量。 特点： 修饰方法，方法不能被重写。 修饰类，类不能被继承。 修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。 常量： A:字面值常量 'a',12,"hello" B:自定义常量 就是把变量用final修饰。 定义一个常量。 final 数据类型 变量名;
三、多态
多态：同一个对象,在不同时刻表现出来的不同状态。
多态的前提： A:有继承关系 B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义） C:有父类引用指向子类对象 Fu f = new Fu(); 左边：Fu类型的引用 右边：Fu类型的对象 Zi z = new Zi(); Fu f = new Zi(); 3.2 成员访问特点 A:成员变量 编译看左边,运行看左边 B:构造方法 子类构造默认访问父类的无参构造 C:成员方法（重点理解） 编译看左边,运行看右边 为什么变量和方法不一样呢? 方法重写。 D:静态成员方法 编译看左边,运行看左边 因为静态的内容是和类相关的，与对象无关。
四、抽象类
抽象类特点: A:抽象类和抽象方法必须用abstract关键字修饰 B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类 C:抽象类不能实例化 那么，如果实例化并使用呢? 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。 D:抽象类的子类 要么是抽象类 要么重写抽象类中的所有抽象方法 抽象类的作用： 强制要求子类必须要重写某些方法。 类的组成： 成员变量： 构造方法： 成员方法： 抽象类的成员： 成员变量：可以是变量，也可以是常量。 构造方法：有构造方法 不能实例化,构造方法有什么用呢? 用于子类访问父类数据的初始化。
成员方法：既可以是抽象的，也可以是非抽象的。
例子：以动物类、猫类为例
public abstract class Animal { private String type; private String name; public Animal(){} public Animal(String type,String name){ this.name = name; this.type = type; } public void setType(String type){ this.type = type; } public String getType(){ return type; } public void setName(String name){ this.name = name; } public String getName(){ return name; } //吃饭的抽象方法 public abstract void eat(); }创建一个猫类： public class Cat extends Animal{ public Cat(){} public Cat(String name,String type){ setName(name); setType(type); } @Override public void eat() { System.out.println("猫爱吃鱼"); } //猫会捉老鼠 public void catchMouse(){ System.out.println("猫会逮老鼠"); } }继承了动物类，对eat方法进行了重载，且加入了catchMouse方法创建Text类，进行测试
public static void main(String[] args) { //使用猫的有参构造创建一个对象 Animal a2 = new Cat("bob", "加菲猫"); a2.eat(); System.out.println(a2.getName()+" "+a2.getType()); }五、接口接口：实现接口代表着这个类自身功能的一种扩展，所以接口代表着一种扩展的能力
接口的特点：
A:定义接口要用关键字interface表示 格式：interface 接口名 {} B:类实现接口用implements表示 格式：class 类名 implements 接口名 {} C:接口不能实例化 那么，接口如何实例化呢? 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。 D:接口的实现类 要么是抽象类 要么重写接口中的所有抽象方法 多态的前提： A:有继承或者实现关系 B:有方法重写 C:有父类引用或者父接口引用指向子类或者实现类对象 多态分类： A:具体类多态 B:抽象类多态 C:接口多态
接口的成员特点： A:成员变量 只能是常量。 默认修饰符：public static final B:构造方法 没有构造方法 C:成员方法 只能是抽象方法。 默认修饰符：public abstract
类与类： 继承关系。只能单继承，可以多层(重)继承。 类与接口： 实现关系。可以单实现，也可以多实现。 还可以在继承一个类的同时实现多个接口。 接口与接口： 继承关系。可以单继承，也可以多继承。
接口和抽象类的关系最后分析： 抽象类和接口的区别 A:成员区别 抽象类： 成员变量：可以是变量，也可以是常量 构造方法：有构造方法 成员方法：可以是抽象方法，也可以是非抽象方法 接口： 成员变量：只能是常量。默认修饰符 public static final 成员方法：只能是抽象方法。默认修饰符 public abstract B:关系区别 类与类： 继承关系。只能单继承，可以多层(重)继承。 类与接口： 实现关系。可以单实现，也可以多实现。 还可以在继承一个类的同时实现多个接口。 接口与接口： 继承关系。可以单继承，也可以多继承。 C:设计理念区别 抽象类被继承体现的是："is a"的关系。抽象类定义的是共性功能。 接口被实现体现的是："like a"的关系。接口定义的是扩展功能。
接以上的动物类，创建一个接口
public interface Inter { public abstract void jump(); } 创建一个JumpCat类 public class JumpCat extends Cat implements Inter{ public JumpCat(){} public JumpCat(String name,int age){ setAge(age); setName(name); } @Override public void jump() { System.out.println("经过多年的刻苦训练，终于练成了跳高技能"); } } 创建Text类测试 public class Test { public static void main(String[] args) { //多态的方式创建一个普通猫 Animal a = new Cat(); a.eat(); Cat c = (Cat)a; c.catchMouse(); System.out.println("------------------"); //创建一个跳高猫 JumpCat jc = new JumpCat(); jc.eat(); jc.catchMouse(); jc.jump(); } }
