继承基础知识

1.理解

java中提供一个关键字extends，是一个类与另一个类建立继承关系。

public class Student extends Person{}

如上，Student为子类（派生类），Person为父类（基类或超类）。

2.super关键字

若在子父类中出现重名，由就近原则优先调用子类；如用上super，则会调用父类。

（1）super与this：super是父类存储空间标识，this是调用本类成员

//访问成员变量
super.父类成员变量;
this.本类成员变量;
//访问成员方法
super.父类成员方法();
this.本类成员方法();
//访问构造方法
super();super(...);
this();this(...);
//注意：this()和super()都要争夺构造方法第一排的位置，故二者不能共存

以访问成员变量举例：

public class Fu{
    int age=45；
}
class Zi extends Fu{
    int age=18；
        public void method(){
        int age=19;
        System.out.println(age);//结果：19
        System.out.println(this.age);//结果：18
        System.out.println(super.age);//结果：45
    }
}

（2）方法的重载（Overload）和方法的重写（Override）

Overload：在同一个类中，方法名相同，参数不同（类型不同，数量不同，顺序不同），与返回值无关。

Override：在子父类中，出现了方法声明一模一样的方法（方法名，参数，返回值）。

注：父类中私有方法不能被重写。子类重写父类方法时，访问权限必须大于等于父类。

3.java中继承的特点

只支持单继承，不支持多继承，但支持多层继承。

public class Fu{   
}
class Zi1 extends Fu{
    
}
class Zi2 extends Zi1{
    
}

4.继承中成员访问特点——构造方法

父类中的构造方法无法被子类继承，但是在子类中，其中会自动补充super();用于访问父类的构造方法。

//在一个class文件中创建父类
public class Father{
    private String name;
    private int age;
    //空参构造方法（注意方法名与类名保持一致）
    public Father(){
        
    }
    //带参构造方法
    public Father(String name,int age){
        this.name;
        this.age;
    }
    //对于private，要写出对应的set，get方法
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
    
}

//创建子类
//因为子类无法继承父类的构造方法，故还需我们写
public class Son extends Father {
    public Son(){
        
    }
    public Son(String name,int age,String mood){
        super(name,age);//此处通过super访问调用了父类的构造方法
        private String mood;//父类中没有的变量要自己再声明
        public String getMood(){
        return mood;
    }
    public void setMood(String mood){
        this.mood=mood;
    }
    }
    //提供一个talk方法
    public void talk(){
        System.out.println("年龄为"+super.getAge+"的"+super.getName+"正在讲话"+"ta的心情"+ mood )；
    }
}

//创建测试类
public class Text{
    public static void main(String[] args){
        Son s = new Son("安琪拉",16, happy);//数据先到子类中的带参构造方法中，再通过super到父类的带参构造方法中
        //而后父类对自己的成员变量赋值，最后在从测试类中通过get类方法对其进行使用
        System.out.println(getName+","+getName);
        s.talk();
       
    }
}

5.抽象类（abstract）

1.抽象类是一种特殊的父类，将子类中共同的方法抽取到父类后，无法准确描述时，可设计抽象方法

public abstract class Family{
    public abstract void work();//抽象方法存在于抽象类中
}
class Son extends Family{
    public void work(){
        System.out.println("儿子上小学");//抽象类的子类中还需要重新方法
    }
}
class Daughter extends Family{
    public void work(){
        System.out.println("女儿上高中");
    }
}

2.注意：抽象类不能实例化，但是存在构造方法（可以交给子类，通过super访问），可以存在普通方法（让子类继承），与private（不允许子类重写），final（不允许子类重写），static（可通过类名调用）冲突。

final关键字

1.特点：

1.修饰方法：表明这是最终方法，不能被重写

2.修饰类：表明这是最终类，不能被继承

3.修饰变量：表明该变量是常变量，不能被再次赋值（修饰引用数据类型时，数据值可以改变，地址值不可改变）

//修饰类
final class FU{
    //太监类
}
//修饰方法
class Ma{
    public final void METHOD(){
        System.out.println("这个方法不能被重写啦！")
    }
}
//修饰成员变量
public class Demo{
    public static void main (String[] args){
        final int NUM=10;//定义的时候直接赋值，也可以在构造方法中赋值
        NUM=20;//此处报错，num已经被final修饰，此处不能再次赋值
    }
}

1.命名规范

1.如果变量名只有一个单词，全部大写

2.如果有多个单词，全部大写，单词之间用下划线(_)隔开