java 继承

1，构造函数：没有返回类型，类名和方法名相同；

2， 子类继承父类，子类就有了父类的属性，创建子类对象时，会先执行父类的构造函数，然后执行子类的构造函数，完成对象的创建，系统之所以自动的调用父类的构造函数是因为子类构造函数的最上端隐含着"super()"；

3，this 调用全部的变量 super 调用父类的变量

this（）：调用本身的构造函数 包括继承类的 super（）只能继承父类的构造函数；

4，private 类的内部进行访问 public 所有的类都可以访问，default 只能同包类访问，prtected 同胞类或者一异包类访问  子类可以访问父类的public，protected 成员不能访问private default成员

5，子类拥有与父类相同成员的情况成为覆盖

成员变量的覆盖 变量名相同；成员函数的覆盖 返回值类型 方法名 形式参数都相同；

覆盖父类成员在于子类可以重新定义扩展父类的功能；

private->public ;default->public ;访问权限子类可以和父类相同或者大于父类；

6 ，equals() 两个对象内容相同时候可以进行比较 相同返回true;

A instananceof B   A是类B的对象返回true 否则返回false;

父类：

public class person {

    private int age;
    private String nameString;
    private String sex;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getNameString() {
        return nameString;
    }
    public void setNameString(String nameString) {
        this.nameString = nameString;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "person [age=" + age + ", nameString=" + nameString + ", sex=" + sex + "]";
    }
    public void work() {
        System.out.println("我可以做工作");
    }

/*构造方法的重载
    public person(int age, String nameString, String sex) {
        super();
        this.age = age;
        this.nameString = nameString;
        this.sex = sex;
        System.out.println("我是person有参构造方法");
    }
    
    static {
        System.out.println("我是静态代码块");
        }
    {
        System.out.println("我是动态代码块");
    }
    public person(){
        System.out.println("我是person构造函数");
    }

}
 

子类一：

public class player  extends person{

    private String play;
    
    public String getPlay() {
        return play;
    }

    public void setPlay(String play) {
        this.play = play;
    }

    public player() {
        super();
        System.out.println("我执行了player的空参构造方法");
        // TODO Auto-generated constructor stub
    }

    public player(int age, String nameString, String sex,String play) {
        super(age, nameString, sex);
        this.play=play;
        System.out.println(this.getNameString()+"是运动员可以"+this.play+super.getSex());
        // TODO Auto-generated constructor stub
    }

    @Override
    public void work() {
        // TODO Auto-generated method stub
        System.out.println("我可以去工作");
        super.work();
        super.setAge(18);
    }

    
}
子类二：

public class teacher extends person {

    private String teach;
    
    public String getTeach() {
        return teach;
    }

    public void setTeach(String teach) {
        this.teach = teach;
    }
    

    public teacher(String teach) {
        super();
        this.teach = teach;
    }

    @Override
    public void work() {
        // TODO Auto-generated method stub
        super.work();
        System.out.println("我可以交给学生知识");
    }

    public teacher() {
        super();
        System.out.println("我执行了空参的teacher构造方法");
        // TODO Auto-generated constructor stub
    }

    public teacher(int age, String nameString, String sex,String teach) {
        super(age, nameString, sex);
        this.teach=teach;
        System.out.println(this.getNameString()+"可以教"+teach);
        // TODO Auto-generated constructor stub
    }
    
}
测试类：

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        player soccerPlayer = new player(18,"江飞","男","足球");
        teacher t1=new teacher(19,"红玉","女","数学");
        person p1=new person(19, "刘红", "女");
        person p2=new teacher();//向上转型 自动 
        //p2 只能引用继承至person类的成员和覆盖的函数和成员 teacher中本身的成员无法引用
        teacher p =(teacher)p2;
        //像p2,父类型引用子类型的对象时，父类型引用变量p1可以转换成子类型，p为转换成的子类型，可以引用p2所不能引用的子类成员
        //player a=(player)p1;//向上转型 强制转
        System.out.println(p2.equals(p)); 
        test t =new test() ;
        t.profession(p);
        t.profession(soccerPlayer);
    }

//测试 传进来的对象是什么类型

    public void profession(person p) {
        if(p instanceof teacher) {
            System.out.println("是老师");
        }
        if(p instanceof player) {
            System.out.println("是运动员");
        }
        
    }
}
 执行顺序

静态代码块>动态代码块>构造函数

静态代码块执行一次 动态每遇见一次执行一次，构造函数每次创建该对象都会执行；