目录
一.初识继承：
1.1什么是继承，为什么需要继承：
1.2继承的概念与语法：
二.成员的访问：
2.1super关键字
2.2this和super的区别：
三.再谈初始化:
小结：
四.初识多态：
4.1多态的概念：
4.2多态的实现条件：
一.初识继承：
1.1什么是继承，为什么需要继承：
Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。??? 那具体来说是怎么样的呢？???举个例子，比如猫狗，他们都是一个动物：
用Java语言来描述就是：
class Cat{ public String name; public int age; public Cat(String name, int age) { this.name = name; this.age = age; } public void eat(){ System.out.println(this.name+"正在吃！"); } } class Dog{ public String name; public int age; public Dog(String name, int age) { this.name = name; this.age = age; } public void eat(){ System.out.println(this.name+"正在吃！"); } } public class Test1 { public static void main(String[] args){ Dog dog = new Dog("小黄",5); dog.eat(); Cat cat = new Cat("小花",6); cat.eat(); }}通过观察，我们可以发现，其中有诸多的地方重复，但是两个对象都从属于动物，那能否将这些共性抽取呢？面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。???
1.2继承的概念与语法：
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。????
语法实现：
修饰符 class 子类 extends 父类 {// ... }具体来说：
class Animal{ public String name; public int age; public Animal(String name, int age) { this.name = name; this.age = age; } public void eat(){ System.out.println(this.name+"正在吃！"); }}//子类会继承父类的内容，所以子类无需自己定义其他内容class Dog extends Animal { public Dog(String name, int age) { super(name, age); //当子类继承父类之后，要先帮助父类进行成员的初始化 } //此时需要通过super关键字来实现 public void bark(){//子类中特有的方法 System.out.println(this.name+"正在汪汪汪~"); }} class Cat extends Animal{ public Cat(String name, int age) { super(name, age);//当子类继承父类之后，要先帮助父类进行成员的初始化 } //此时需要通过super关键字来实现 public void miaomiao(){//子类中特有的方法 System.out.println(this.name+"正在喵喵叫~"); } } //测试方法public class Test1 { public static void main(String[] args){ Dog dog = new Dog("小黄",5); dog.eat();//dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的 dog.bark(); System.out.println("======================================="); Cat cat = new Cat("小花",6); cat.eat();//cat类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的 cat.miaomiao(); }}输出结果：
注意：
?子类会将父类中的成员变量或者成员方法继承到子类中了 ?子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了 ?当子类继承父类之后，要先帮助父类进行成员的初始化，此时需要通过super关键字来实现。（后面介绍super关键字）二.成员的访问：
在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？???答案是可以的，这时就需要用到super关键字：2.1super关键字
?super.data:访问父类的成员变量
?super.func()：访问父类的方法
?super():访问父类的构造方法
class Base{ protected int a; protected int b; protected int c; protected int d; public Base(int a, int b, int c, int d) { this.a = a; this.b = b; this.c = c; this.d = d; } public void methodA(){ System.out.println("父类的方法!"); }}class Drived extends Base{ int c; int d; public Drived(int a, int b, int c, int d) { super(a, b, c, d);//访问父类的构造方法 } @Override public String toString() { return "Drived{" + "a=" + a + ", b=" + b + ", c=" + c + ", d=" + d + '}'; } public void method(){ super.a = 10; super.b = 20;//supr.data直接访问父类成员变量 d = 30;//访问从父类继承下来的d this.c = 40; this.a = 20;//覆盖了刚才调用的父类成员变量 } public void methodB(){ super.methodA();//调用父类的方法 System.out.println("子类的方法！"); }}public class Test1 { public static void main(String[] args){ Drived d = new Drived(0,0,0,0); d.methodB(); d.method(); System.out.println(d); }}运行结果：
? 其中成员的访问顺序是：先看子类有没有，子类有，优先访问子类的成员，子类没有，去父类中找，父类中也没有，就报错。
2.2this和super的区别：
super 和 this 都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？ 相同点： 1.? 都是 Java 中的关键字 2.? 只能在类的非静态方法中使用，用来访问非静态成员方法和字段 3. ? 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
不同点：
三.再谈初始化:
在对成员变量进行初始化的过程中，我们会用到静态代码块，实例代码块和构造方法，那在实际的运行过程中，他们的运行次序是怎样的呢？我们先看以下代码：class Animal { public String name; public int age; public String color; static { System.out.println("父类的静态代码块，Animal::static{}"); } { System.out.println("父类的实例代码块，Animal::{}"); } public Animal(String name, int age, String color) { this.name = name; this.age = age; this.color = color; System.out.println("父类的构造方法，Animal(String,int,String)"); } public void eat() { System.out.println(this.name +" 正在吃饭！"); }}class Dog extends Animal{ static { System.out.println("子类的静态代码块，Dog::static{}"); } { System.out.println("子类的实例代码块,Dog::{}"); } public Dog() { super("haha",10,"黄色");//虽然 调用了父类的构造方法 ， System.out.println("子类的构造方法，Dog()"); // 但是 并没有产生父类对象，此时 只是帮你进行初始化父类的成员 } public void bark() { System.out.println(this.name +" 正在汪汪汪！"); }}public class Test1 { public static void main(String[] args) { Dog dog1 = new Dog(); System.out.println("=============="); Dog dog2 = new Dog(); }}
由此，我们可以得出（执行顺序的）结论：
1.父类的静态代码块，子类的静态代码块
2.父类的实例代码块，父类的构造方法
3.子类的实例代码块，子类的构造方法
----------》静态代码块在整个程序中只执行一次
小结：
继承的好处：
1.提高了代码的复用性（多个类相同的成员可以放在同一个类中）
2.提高了代码的维护性（如果方法的代码需要修改，只修改一处即可）
继承的坏处：
1.继承让类与类建立了关系，类的耦合性增强
2.当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性
四.初识多态：
4.1多态的概念：
通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。????
举例来说就是我们日常生活中的打印机，分为黑白打印和彩印，完成打印这个行为，黑白打印机和彩印机所展现的打印状态完全不同。或则上面的猫狗完成吃东西这个行为，不同的动物也会导致吃东西的状态不同。
4.2多态的实现条件：
在 java 中要实现多态，必须要满足如下几个条件，缺一不可： 1. 必须在继承体系下 2. 子类必须要对父类中方法进行重写 3. 通过父类的引用调用重写的方法 4.2.1那么什么是重写？? 重写 (override) ：也称为覆盖。重写是子类对父类非静态、非 private 修饰，非 final 修饰，非构造方法等的实现过程 进行重新编写, 返回值和形参都不能改变 。 即外壳不变，核心重写！ 重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。 简单总结重写就是： 1.方法名相同 2.方法的参数列表相同（个数，顺序，类型） 3.方法的返回值类型相同 4.2.2那什么是向上转型？ 向上转型：实际就是创建一个子类对象，将其当成父类对象来使用 语法格式：父类类型 对象名 = new 子类类型 ()
animal 是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。 
实现多态的代码： class Shape { public void draw() { System.out.println("画图形！"); }}class Rect extends Shape { @Override public void draw() { System.out.println("画一个矩形！");//重写父类方法 }}class Cycle extends Shape{ @Override public void draw() { System.out.println("画一个圆圈！"); }}class Triangle extends Shape { @Override public void draw() { System.out.println("画一个三角形！"); }}class Flower extends Shape { @Override public void draw() { System.out.println("画一朵花！"); }}public class Test1 { public static void drawMaps1() { Rect rect = new Rect();//通过父类的引用调用重写的方法-》向上转型 Shape shapeCycle = new Cycle();//通过父类的引用调用重写的方法-》向上转型 Triangle triangle = new Triangle();//通过父类的引用调用重写的方法-》向上转型 Flower flower = new Flower();//通过父类的引用调用重写的方法-》向上转型 Shape[] shapes = {shapeCycle,rect,rect, shapeCycle,triangle,flower}; for(Shape shape : shapes) { shape.draw();//调用同一个方法，不同的对象会有不同的结果 } } //测试方法 public static void main(String[] args) { drawMaps1(); }}运行结果（这里调用了同一个方法，但是不同的对象会产生不同的结果）：
小结：
1，多态是方法的多态，不是属性的多态（多态和属性无关）
2，多态的存在要有3个必要的条件：继承 | 接口的实现，方法重写，父类引用指向子类对象。
3，父类引用指向子类对象后，用该父类引用调用子类重写的方法（ 父类类型 引用名 = new 子类类型（）； ），此时多态就出现了。
结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固自己的知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！
