继承~~~

package com.oop.Demo05;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-28 19:26
 **/


//在java中，所有的类，都默认直接或者间接继承Object
//Person 人：父类
public class Person
{
    //public  可以不写
    //protected
    //default
    //private

    private int money =10_0000_0000;


    public void say() {
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

package com.oop.Demo05;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-28 19:26
 **/

//学生 is 人：派生类，子类，继承了Person就会拥有父类的全部方法！
public class Student extends Person {
}
//ctrl+H  继承的快捷键

//    Student student =new Student();
//    student.say();

super的知识点及注意事项：
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法

VS this：
代表的对象不同
this：本身调用者这个对象
super：代表父类对象的引用

前提：
this：没有继承也可以使用
super：只能在继承条件下才可以使用

构造方法：
this():本类的构造；
super():父类的构造；

父类：

package com.oop.Demo06;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-29 10:40
 **/
public class Person {


    public Person(){
        System.out.println("person无参构造被执行了");
    }

    protected String name="liyang";

    //私有的东西无法被继承，所以无法继承以下方法
    // private  public void print(){
    //        System.out.println("person");
    //    }

    public void print(){
        System.out.println("person");
    }

}

子类：

package com.oop.Demo06;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-29 10:41
 **/
public class Student extends Person {

    public Student(){
        //隐藏代码super(); 默认会先调用父类的无参构造方法
        //super();该行代码如果写出来，必须放在子类构造器的第一行，否则报错
        //但是该行代码可以不写的
        //当父类重写了有参构造之后，父类的无参构造就不能调用了
        System.out.println("student无参构造被执行了");
    }

    private String name = "alva";

    public void test(String name) {
        System.out.println(name);//阳
        System.out.println(this.name);//alva
        System.out.println(super.name);//liyang
    }

    @Override
    public void print() {
        System.out.println("student");
    }

    public void test1(){
        print();//student
        this.print();//同print，student
        super.print();//父类，person
    }
}

application：

package com.oop.Demo02;
import com.oop.Demo03.Pet;
import com.oop.Demo06.Student;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-24 15:53
 **/
public class Application {
    public static void main(String[] args) {
        Student student=new Student();
//        student.test("阳");

//        student.test1();






    }
}

//

---

方法重写

***@override

//父类
package com.oop.Demo07;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-29 14:11
 **/
public class B {
    public /*static*/ void test(){
        System.out.println("B->test()");


    }
}

//子类
package com.oop.Demo07;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-29 14:11
 **/
public class A extends B{
    //override 重写
    @Override  //注解，有功能的注释！
    public /*static*/ void test(){
        System.out.println("A->test()");


    }

}

应用类

package com.oop.Demo02;
import com.oop.Demo03.Pet;
import com.oop.Demo06.Student;
import com.oop.Demo07.A;
import com.oop.Demo07.B;

/**
 * @program: JavaSE
 * @description:
 * @author: lijiaoyang
 * @create: 2021-06-24 15:53
 **/
public class Application {
    //静态的方法和非静态的方法区别很大！

    public static void main(String[] args) {
        //静态方法：方法的调用只和=左边定义的数据类型有关系
        A a =new A();
        a.test();//A
        B b = new A();
        b.test();//还是调用的B中的方法

        //非静态方法：重写
        A a =new A();
        a.test();//A
        B b = new A();//子类重写了父类的方法
        b.test();//调用的A中的方法




    }
}