一、继承
继承：你继承谁你就是谁，继承是一种严格的父子关系（在父类里面抽取的属性和方法一定是所有子类所共有）
（Student继承Person，那么Student就是人）
//使用继承的好处
可以把多个子类中重复的代码抽取到父类中，提高代码的复用性
子类可以在父类的基础上，增加其他功能，使子类更强大
//什么时候使用子类
当类与类之间，存在相同的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码
java支持单继承，不支持多继承，但支持多层继承
继承中成员变量访问特点：就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上.
继承中成员方法的访问特点：直接调用满足就近原则，super调用，直接访问父类
继承中构造方法的访问特点：
1；父类中的构造方法不会被子类继承
子类中所以的构造方法默认先访问父类中的无参构造，再执行自己，因为子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化
2；怎样调用父类构造方法
子类构造方法的第一行语句默认都是super()，不写也存在，且必须在第一行
UML类图（描述类与类之间的关系）
父类：person
public class Person {
//一个类不继承任何一个类，默认继承Object
//希望被子类继承，用protected
protected int id;
protected String name;
protected int age;
public Person(){
}
public Person(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public void show(){
System.out.println("Person.show");
}
}子类：student(student show方法里super.show)
public class Student extends Person {
int id;
String name;
int age;
public Student(){
}
public Student(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public void show(){
super.show;
System.out.println("student.show");
}
public void study(){
System.out.println("Student.student");
}
Test类
访问修饰符
import：
Java里面要到类需要import进来，本包的类不需要import，外部包需要import
特例：java.lang包放很多Java常用类像System、String，这个包下面是不需要导包
this、super总结：
- this:代表当前类的对象 this.id=id
- super：代表父类对象
- this():调用当前类的构造方法
- super():调用父类构造方法
二、重载
重载（Overload）是指在同一个类中可以有多个方法拥有相同的名称，但是它们的参数列表不同。
Java通过方法的参数类型、个数或顺序来区分不同的重载方法。
最典型的重载：构造方法重载（无参构造方法、有参构造方法）
方法重载特点：与返回值无关，只看参数列表。
void show(int a, char b, double c){}
1、void show(int x, char y, double z){} 不是重载，是同一个方法
2、int show(int a, double c, char b){} 是重载，参数顺序不一样，和返回值无关
3、void show(int a, double c, char b){} 是重载，参数顺序不一样
4、boolean show(int c, char b){} 是重载
5、void show(double c){ } 是重载
6、double show(int x, char y, double z){} 不是重载
三、重写
重写（覆盖）@Override
父类中定义的方法子类不满意，子类重新定义这个方法，最典型的重写就是toString()
1、子类覆盖父类，必须保证子类权限大于父类权限才可以覆盖，否则会编译失败。
2、如果父类是private的方法，子类是默认方法，那么子类是不知道这个方法的，不是覆盖。
父类方法：
子类重写父类方法：
四、多态
在person父类，student，teacher子类中； student= new student(); person = new student(); //学生是学生，学生也是人；就是多态
多态：同类型的对象，表现出的不同形态 多态的表现形式： 父类类型 对象名称 = 子类对象；
多态调用成员的特点 1：调用成员变量：编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变 量，如果有编译成功，如果没有编译失败 运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变 量的值 2：调用成员方法：编译看左边 运行看右边：运行代码的时候，实际运行的是子类的方法Java 多态（Polymorphism）是面向对象编程的一项核心概念，它允许对象以多种形式出现。 多态性在Java中有两个主要的表现形式：
- 编译时多态（也称为静态多态）
- 运行时多态（也称为动态多态）
多态存在的三个必要条件：
- 继承
- 重写
- 父类引用指向子类对象 Cal cal = new Add();
Cal类：
public abstract class Cal {
protected int num1;
protected int num2;
public Cal() {
}
public Cal(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
}
public abstract int getResult();
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
}
Add类
public class Add extends Cal{
public Add() {
}
public Add(int num1, int num2) {
super(num1, num2);
}
@Override
public int getResult(){
return num1 + num2;
}
}Sub类
public class Sub extends Cal {
public Sub() {
}
public Sub(int num1, int num2) {
super(num1, num2);
}
@Override
public int getResult(){
return num1-num2;
}
}MUL类
public class MUL extends Cal{
public MUL() {
}
public MUL(int num1, int num2) {
super(num1, num2);
}
@Override
public int getResult(){
return num1*num2;
}
}
TEST类
public class Test {
public static void main(String[] args) {
Add add = new Add(3,5);
System.out.println(add.getResult());//8
Cal cal=new Add(2,5);
int result1=cal.getResult();
System.out.println(result1);//7
cal=new Sub(8,4);//多态
int result2=cal.getResult();
System.out.println(result2);//4
MUL mul=new MUL(2,4);
jisuan(mul);
}
public static void jisuan(Cal cal){
cal.getResult();
}
}