java 继承，抽象类，final关键字

继承：子类通过extends调用父类中的属性和方法。

继承：提高代码复用性，减少代码冗余。

格式：class 子类 extends 父类{};

继承的实现：现在子类中寻找，子类没有，再在父类中寻找（就近原则）。

子类不可以调用父类中的任何被private修饰的属性和方法。

继承的特点：java只支持单一继承。因为如果父类成员重名时，会产生冲突问题。

class A{
int a = 100;
}
class B extends A{
int a = 200;
} //ok
class C extends B,A{} //error

java支持多级继承（爷爷爸爸孙子）

class A{

int a = 100;

}

class B extends A{

int b = 200;

}

class C extends B{} // C里边有两个变量
成员访问特点

总体规则：当访问成员时，先在子类中找，有则使用，没有在去父类中找。但是不能访问父类私有成员。

package** demo04_继承_成员访问规则;

```java **public class** Fu {
     **private int b** = 300;
     **int a** = 100;
     **public void** show(){
         System.**out**.println(**"****父类的show方法"**);
     }
 }
```



package** demo04_继承_成员访问规则;

 **public class** Zi **extends** Fu {
     **int a** = 200;
     **public void** show(){
         System.**out**.println(**"****子类的show"**);
     }
 }

```

```

package 

demo04_

继承

_

成员访问规则

;

 */**  ** 

总体规则：当访问成员时，先在子类中找，有则使用，没有在去父类中找。
  */

public class 

Test {

     **public static void** main(String[] args) {
         Zi zi = **new** Zi();
         System.**out**.println(zi.**a**);*//100*         zi.show();
 *//        System.out.println(zi.b);//*

编译报错
     

}
}

方法重写：

子类中定义了和父类之中一模一样的方法（除了方法体不一样）成为方法的重写。

作用：子类继承父类就可以使用的方法，但是当父类的方法不满足于子类的需求是，子类可以重写该方法。

注意：子类方法修饰符权限应该大于父类的方法权限修饰符。

public protectd 什么都不写 private（四个权限修饰符，依次变小）

this 和super

子类不可以继承父类的构造方法，因为构造方法和类名保持一致，每个类都有各自的构造方法。

构造方法的作用是初始化对象成员属性的。子类继承父类就额可以使用的成员属性，所以父类应该先把成员属性初始化好。子类进行初始化动作时，就先调用父类的初始化动作。

就是在子类在定义自己的构造方法的时候，就已经默认调用了父类的无参构造方法。（在子类的构造方法之中第一行隐藏了一个super（）方法。）

package** demo05_继承_构造方法;
 
 **public class** Fu {
     **int a** = 100;
     *//**无参*     **public** Fu(){
         System.**out**.println(**"****父类无参构造方法"**);
     }
 
     **public** Fu(**int** a) {
         **this**.**a** = a;
         System.**out**.println(**"****父类有参构造方法"**);
     }
 }

**package** demo05_继承_构造方法;
 
 **public class** Zi **extends** Fu {
     **int a** = 200;
     *//**无参*     **public** Zi(){
         **super**();*//**调用父类无参构造方法*         System.**out**.println(**"****子类无参构造方法"**);
     }
 
     *//**有参*     **public** Zi(**int** a) {
         **super();//****调用父类无参构造方法** **只能在第一行代码位置上**         **this**.**a** = a;
         System.**out**.println(**"****子类有参构造方法"**);
     }
 }

package 

demo05_

继承

_

构造方法

;

 **public class** Test {
     **public static void** main(String[] args) {
         Zi zi = **new** Zi();
         Zi z2 = **new** Zi(10);
     }
 }

this关键字

1.指的是当前对象引用，哪个对象调用方法，this指的就是谁。

2.作用：区分成员变量和局部变量重名的问题。

3.用法：只能够在本类方法中。

4.1）在本类成员方法中，访问本类成员变量。

2）在本类成员方法中，访问本类的其他成员方法。

3）在本类的构造方法中，访问其他的构造方法。

super关键字

1.子类对父类对象的引用。

2.自在类方法中访问父类的成员变量，成员方法和构造方法。

3.在子类的成员方法中，访问父类的成员变量。

在子类的成员方法中，访问父类的成员方法。

在子类的构造方法中，访问父类的构造方法。

抽象类

抽象方法：没有具体实现的方法。

public abstract void eat();

抽象类：包含抽象方法的类一定是抽象类（但是抽象类却不一定有抽象方法。）

public abstract class Animals{}

抽象类不能够创建对象，假如抽象类可以创建对象，那么就可以通过对象调用方法，但是抽象类没有具体的实现，调用没有意义。

抽象类就是做父类使用的。子类继承抽象类必须重写抽象类中所有的抽象方法。否则子类就必须也是抽象类。

抽象类中的成员：成员变量成员方法构造方法抽象方法（都不是必须存在的）

抽象类的特点：

1.抽象类不可以创建对象，本身就是做父类使用的

2.抽象类不可以创建对象，但是有构造方法

3.抽象类不一定有抽象方法，但是抽象方法一定定义在抽象类中

4.子类继承抽象类必须重写抽象类中的所有抽象方法，否则子类也必须是抽象类。

模板设计模式

1.设计模式：在解决某类问题而形成的固定的行之有效的解决方案。

2.java设计模式：利用java设计语言的特性，在实际开发中为了解决某一类问题形成的通用的解决方案：单例模式，多例模式，模板设计模式等等。

3.模板设计模式：模板：固定的形式，例如作文模板，合同等。

模板设计模式：将通过的固定的形式定义在父类中，父类不能确定的（例如合同个人信息）定义为抽象方法，让子类继承并强制重写。

final关键字

关键字可以使用的位置：类，成员方法，成员属性，构造方法，局部变量。

final关键字：表示最终的，不可变的。可以修饰类，成员方法，变量。

final修饰类：表示此类不可以被继承。

final修饰方法：表示此方法不可以被重写

final修饰变量：修饰基本类型变量，表示此变量不可以被修改，相当于常量。

修饰引用类型变量是，表示此类型存放的对象的内存地址不可以被修改，但是对象内容可以修改。

定的（例如合同个人信息）定义为抽象方法，让子类继承并强制重写。