面向对象的三大特征：（封装、继承、多态）之 封装 和 继承（Super关键字的使用【全】）

封装

封装：通俗来说就是 归纳总结

			归纳总结！！！
			循环封装过程
			方法封装功能
			类封装数据
			框架封装模块
			一段代码使用了三遍，做成一个循环
			一个循环使用了三遍，做成一个方法
			一个方法使用了三遍，做成一个工具类
			一个工具类使用了三遍，做成一个文档
			一个文档使用了三遍，做成一篇博客

继承：

       继承在开发中是一种抽象的归纳总结思想，剥离通用的属性，通用的方法，简化之后提高开发速度。只需要在继承之后，满足个性化的
实现即可。通过继承可以优化代码，在JavaWEB开发中，继承大多数情况
下，都是用来提高方法的复用度。
继承的书写：

			关键字:
			extends
			格式:
			class A extends B {
			}
			A类是B类的一个子类
			B类是A类的唯一父类
			【Java是一门单继承语言，一个类有且只能继承一个父类】

【重点】
1️⃣在使用继承的时候，被private修饰的类不能被子类继承。(补充一点private修饰的类只能是内部类，外部类不存在类private修饰的情况)
2️⃣在使用继承的时候子类可以直接调用父类的成员变量和成员方法，但不可以调用被private修饰的成员变量、成员方法，但是可以通过super关键字调用（super关键字后续博文会介绍）。
3️⃣ A类使用extends关键字继承B类
A类是B类的一个子类，B类是A类的唯一父类。

注意：在创建子类对象的时候，在执行子类构造方法时必定先创建父类对象（调用父类构造方法）。

继承代码演示：
父类代码：

class Father {
	public int height;
	private int testPrivate;
	public void game() {
		System.out.println("钓鱼，象棋~~~");
	}
	private void privateMethod() {
		System.out.println("私有化方法");
	}
}

子类代码：

/*
* Son类是Father类的一个子类
* Father类是Son类的唯一父类
*/
class Son extends Father {
	public int age;
	public void study() {
		System.out.println("子类学习方法！！！好好学习，天天向上！");
	}
}

测试代码：

public class Demo1 {
	public static void main(String[] args) {
	// 创建一个Father类对象
	Father father = new Father();
	// 通过Father类对象，使用father类内的成员变量和成员方法
	father.height = 170;
	father.game();
	System.out.println(father.height);
	System.out.println("------------------------------------");
	// 创建一个Son类对象
	Son son = new Son();
	// 使用Son类对象，调用Son类自己的成员变量和成员方法
	son.age = 16;
	son.study();
	System.out.println(son.age);
	// 使用Son类的对象，调用通过继承得到的父类【内容】
	}
}

不可继承【重点】

1️⃣ 构造方法：类中的构造方法，只负初始化创建本类的对象，不可被继承。
2️⃣private 修饰的成员方法和成员变量。
3️⃣父子类不在同一个package下，default修饰的属性和方法。（default----访问修饰符的一中）。

访问权限修饰符

修饰符	本类	同包	非同包子类	其他
private	✔	✖	✖	✖
default	✔	✔	✖	✖
protected	✔	✔	✔	✖
public	✔	✔	✔	✔

(protected)提示:
父类中的属性被protected所修饰，且子类与父类不在同一（package）中，子类仍可调用父类中被protected修饰的成员方法或成员变量。
代码示例：
父类：

	package com.llq.homework;
	public class A {
		protected String name;
	}

子类：

package com.llq.extend;
import com.llq.homework.A;
public class B extends A{
	public B() {
		System.out.println(name);
	}
}

测试代码：

package com.llq.extend;
public class Test {
	public static void main(String[] args) {
		new B();
	}
}
//测试结果：null   以为没有对name赋值，因此此时的name的结果为null。

Super关键字

先看个特殊的示例：
有其父才有其子【难点】
父类：

class Father {
	public int height;
	private int testPrivate;
	public Father() {
		System.out.println("我是父类");
	}
}

子类：

public class Son extends Father{
	public Son() {
		System.out.println("我是子类");
	}
}

测试类：

public class TestDemo {
	public static void main(String[] args) {
		new Son();
	}
}
运行结果：
		/**
		*我是父类
		*我是子类
		*/

       由上述代码可知，我们没有实例化父类，但是为什么父类的构造方法会执行呢，这是因为，在进行继承的时候， super()关键字则是隐式存在的。

Super关键字总结：
（1）调用父类的构造器，在存在子父类继承关系的时候，要实例化一个子类的对象，那么必须要首先实例化其父类，就在这时super（）表现了他的作用；

（2）super（）只能出现在子类的构造器中，且必须写在第一行；

（3）super（）中的参数决定了在子类对象实例化时，要调用父类的哪个构造器为父类实例化；

（4）如果子类构造器中没有super（）出现，那么编译器则会默认加上super（）即父类的空构造器（当然这空构造器可以是系统默认产生的那个），若此时父类中没有空的构造器（即父类中声明了一个有参数的构造器，使得系统不再生成默认的构造器），那么编译就会出错；

（5）super关键字可以通过（super.父类成员方法或成员变量）的方式来调用父类中的成员变量或成员方法；

（6）注意：在同一个构造器中不能同时出现super关键字和this关键字！

（7) 在父子类中的方法（重写）或属性存在重名时，若要做出区分，则必须使用super关键字。

代码示例（指总结7中）：
父类：

class A {
	public void m1() {
	}
}

子类：

class B extends A {
	public void m1() {
	  m1();//我们需要调用一次父类的m1()方法
	}
}

测试方法：

class Test {
	public static void main(String[] args) {
		new B().m1();
	}
}
//结果：会导致无穷递归，因此我们需要添加super.m1();