继承（Java面向对象三大特征之一）
1.1、使用继承
1.1.1 编写父类A1.1.2 编写子类B，继承父类A注意 1.2 继承的特性1.3 子类继承父类的什么？
不能被继承的父类成员： 1.4 super和this关键字1.5 继承条件下构造方法的调用原则 二、访问权限控制
2.1 实现类的访问控制2.2 类成员的访问修饰符private修饰符：默认修饰符：（本类、同包）protected修饰符：public修饰符：（任何地方） 三、static 修饰符（静态）
3.1、类的成员变量
3.1.1 类变量（静态变量）3.1.2 实例变量3.1.3 static变量的作用 3.2、static 方法
3.2.1 静态方法3.2.2 实例方法（普通方法） 3.3、静态代码块3.4、注意四、方法重写（override）
方法重写：父子(返回值类型 方法名 （方法的参数列表）)必须都相同4.2 方法重载(overload)和方法重写(override)区别4.5、关于super的理解例子
多个类存在相同属性和行为时，将这此内容抽取单独的一个类中，（类当中抽象出一个类（父类））
减少代码量；方便修改代码
父类（基类）与子类是is-a关系，子类可以直接访问父类非私有的属性和行为
1.1、使用继承 1.1.1 编写父类A访问修饰符 class A{
// 公有属性和方法
}
1.1.2 编写子类B，继承父类A
访问修饰符 class B extends A{
// 子类特有的属性和方法
}
**初始化子类构造方法时，必须先执行父类的构造方法（默认先无参），**子类构造方法中默认有一个super(),表示调用的父类的构造方法，先把父类初始化，再把子类初始化。（先有爸爸） 注意
Java中只支持单根继承，即一个类只能有一个直接父类；
*上图截自菜鸟教程
访问父类的父类的成员，使用一个super. 就可以
1.2 继承的特性子类拥有父类非 private 的属性、方法。子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。子类可以用自己的方式实现父类的方法。提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。 1.3 子类继承父类的什么？
继承public和protected 修饰的属性和方法，不管子类和父类是否在同一包里；
继承默认权限修饰符的属性和方法，但子类和父类必须在同一包里；
不能被继承的父类成员：private 成员；子类与父类不在同一包下，使用默认访问权限的成员；构造方法（只能调用，不能继承） 1.4 super和this关键字
super：父类对象
this：当前对象
如果子类父类中出现了 重名成员变量，这是访问是有影响的！！！
区分同名成员变量，到底是父成员变量还是子成员变量，需要使用super关键字，修饰父类的成员变量，类似于这前所学this；或者可以理解为super可以使被屏蔽掉（子父类成员变量重名了）的成员可见。
使用格式：
super.父类成员变量名
// super();super(name，health，……)——访问父类构造方法
this.子类成员变量名
note：
super调用父类构造方法时只可有一条且必须放在第一句；
super只能出现在子类的普通方法和构造方法里；
1.5 继承条件下构造方法的调用原则
不管是用的无参构造方法的还是有参的去构造子类对象，只要子类的相应构造方法 没有通过super显示调用，系统都默认先走父类无参构造，再走相应子类的无参或带参构造；
如果子类的相应构造方法里出现 通过super显示调用父类有参构造方法，则执行父类相应有参构造方法，而不执行父类无参构造方法。
note：
调用 自己本类的构造方法：
public PP(){} // 无参构造
public PP(String name,int age){
// 方法体
}
public PP(String name,int age,String sex){
this(name,age); // this写于首行
// …………
}
二、访问权限控制
1、类的访问控制；
2、类成员的访问控制；
常用的访问控制修饰符：
public、protected、默认、private
（修饰符用来定义类、方法或者变量，通常放在语句的最前端）
2.1 实现类的访问控制类的访问修饰符：
public修饰符：
公有访问级别，对所有类可见（包括不同包下，导入包即可用）。
使用对象：类、接口、变量、方法
默认修饰符（default，就是什么也不写）：
包级私有访问级别，在同一包内可见，不使用任何修饰符。
使用对象：类、接口、变量、方法
2.2 类成员的访问修饰符private修饰符：
只有本类可访问。
对象：变量、方法。 注意：不能修饰类（外部类）
默认修饰符：（本类、同包） protected修饰符：
对同一包内的类和所有子类可见。（本类、同包、子类）
使用对象：变量、方法。 注意：不能修饰类（外部类）。
public修饰符：（任何地方） 三、static 修饰符（静态）
成员变量
静态变量，可直接通过类名访问
成员方法
静态方法，可直接通过类名访问
代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块 3.1、类的成员变量 3.1.1 类变量（静态变量）
被static修饰的变量；注意：局部变量不能被声明为 static 变量。在内存中只有一个拷贝空间；类的内部，可以在任何方法内直接访问静态变量；其它类中可以通过类名直接调用；（创建实例对象后使用也是可以的）
public class Student{
// 实例变量
int age;
String name;
//类变量
public static String email;
}
public class Test{
public static void main(String[] args){
// 使用
System.out.println(Student.email);// 类名.属性
}
}
3.1.2 实例变量
没有被static修饰的变量；必须通过实例（对象）调用；每创建一个实例都会分配一次内存，可在内存空间有多个拷贝，且互不影响；
public class Student{
// 实例变量
int age;
String name;
}
public class Test{
public static void main(String[] args){
Student stu=new Student();// 创建实例对象
System.out.println(stu.age);// 使用
}
}
3.1.3 static变量的作用
- 能被类的所有实例共享，可作为实例之间进行交流的共享数据；如果类的所有实例都包含一个相同的常量属性，可把该属性定义为静态常量类型，从而节省内存空间。
// 模拟实现选民投票过程：
// 一群选民进行一次投票，当总票数达到100时停止投票
// 选民类
public class Voter {
private static int count;// 投票总数
private static final int MAX_COUNT=100;// 静态常量
private static String name;
// 构造方法
public Voter(){}
public Voter(String name){
this.name=name;
}
// 还可封装
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void voteFor(){
if (count==MAX_COUNT){
System.out.println("已停止投票！");
return; // 结束程序
}else {
count++;
System.out.println(this.name+"投票成功！");
}
}
}
// 测试类
public class TestVoter {
public static void main(String[] args) {
Voter zhang=new Voter("张三");// 1号选民（构造方法的使用）
zhang.voteFor();
for (int i = 1; i <=99; i++) {
Voter names=new Voter("name"+i);
names.voteFor();
}
}
}
3.2、static 方法
3.2.1 静态方法
可直接通过类名访问，（静态方法访问不不能直接访问实例的变量和方法）
静态方法中不能使用 this 和 super 为什么呢？？
静态方法不需要创建对象，而this和super与对象有关；
可直接访问静态变量和静态方法
静态方法必须被实现（得有方法体）
为什么main方法（程序入口）是静态 ???
在加载类的时候就会执行静态方法相关代码，而静态方法与类相关，只要加载类，就会执行与类相关的main方法，不用创建类对象就可以执行。
- 实例方法可直接访问所属类的静态变量、静态方法、实例变量、实例方法
// 打印投票结果
// 静态方法
public static void printRes(){
System.out.println("投票总数："+count);
}
// 在测试类里调用
Voter.printRes();// 通过类名调直接用静态方法
3.3、静态代码块
JVM加载类时，加载静态代码块。
如果有多个静态代码块，按顺序加载依次执行；
每个静态代码块只会被执行一次
public class StaticTest{
static int num=100;// 静态变量
static{ // 两静态代码块依次执行
num+=100;
System.out.println(num);// 200
}
static{
num+=100;
System.out.println(num);// 300
}
}
StaticTest st1=new StaticTest(); StaticTest st2=new StaticTest(); System.out.println(StaticTest.num);// 300 // 打印结果为200 200 3003.4、注意
方法里不能定义static 变量但可以在方法里访问静态变量，static 变量只能在类里定义；
在继承只是继承共性而个性没法很好的实现，怎么办呢：
可以先继承共性，再补全个性，于是我们有了方法重写：
四、方法重写（override）如果子类父类出现 重名的成员方法，这是访问一种特殊情况，叫做方法重写(Override)
方法重写时，可以扩展对父类所定义同名方法，是实现多态的基础。
方法重写：父子(返回值类型 方法名 （方法的参数列表）)必须都相同方法重写里可以调用父类的方法;
note:
先得有继承才能有重写（必须是父子类）！！！
- 方法名相同；参数列表相同；返回值可以不一样；（返回值类型相同或是其子类）访问权限不严于父类；（要么一样要么比你更宽松，public重写时不能是private）
父类的（非）静态方法不能被子类重写为（静态）非静态；
父类的 私有方法 不能被子类重写；( 此时本就不能继承，更不能重写)
不能抛出比父类更多的异常；
看到这里，我们就更加容易理解到：在子类重写父类方法后，这里我们可以理解为父类的方法被屏蔽（覆盖）了，此时通过super. 就可以被屏蔽的成员变量可见。
// 下面这种写法不常见，这里就是第3、的体现
// 父类方法
public Person m1(){
System.out.println("我是父类的m1方法");
return new Person();
}
// 子类方法
public Student m1(){
// 这里Student是Person的一个子类，所以这也是方法重写
System.out.println("我是子类的m1方法");
return new Student();
}
4.2 方法重载(overload)和方法重写(override)区别
类： 方法重载一个类有多个同名方法 ；
父子关系中子类重写父类的方法
方法返回值 ：方法重载可以修改;
方法重写方法返回值类型必须父类相一致
参数列表：方法重载可以修改;
方法重写方法参数列表不能修改
1、重载：同一个类里的多个方法，且它们同名不同参；（与访问权限修饰符、返回值无关）
2、重写：子类里重写父类方法，父子类（两个类），子父类同名同参（注意访问权限和返回值）
4.5、关于super的理解例子// 找到程序入口然后“顺藤摸瓜”
// 父类
public class Father {
String name="Father";
public void m1(){
System.out.println("我是Father类的m1方法");
}
}
// 子类
public class Son extends Father{
String name="Son";
public void m1(){
System.out.println("我是Son类的m1方法");
}
public void varTest(){
super.m1(); // 此时这里才是父类的m1方法
System.out.println(name);// 此时的name="Son"
System.out.println(super.name);// 这里name="Father"
super.m1();// 这时调用的是本类的方法
}
// 程序入口
public static void main(String[] args) {
Son son=new Son();// 找到Son类
son.varTest();// 方法调用
son.m1();// 执行本类的m1方法
}
}
