java18 OOP基础下2022-02-09

/**
继承：
 继承一个父类只能继承非私有的属性和方法；
protected访问权限修饰符在继承关系中使用，父类的属性和方法可以被继承
 构造方法不能被继承
 如果创建子类对象会调用父类默认构造方法
当父类中没有无参构造方法，子类必须显示调用父类有参构造方法，使用super()
*/
public class Test1 {
    public static void main(String[] args) {
        Cat c = new Cat("sansan");
        System.out.println(c.name);
    }
}
class Pet{
    private int age;
    protected String name;

    public Pet() {
        System.out.println("Pet构造方法");
    }

    public void eat(){
        System.out.println("我能吃");
    }
}
class Cat extends Pet{
    public Cat(String name) {
        this.name=name;
    }

    public void sleep() {
        System.out.println("我能睡");
    }
}
class Dog extends Pet{
    public void run(){
        System.out.println("我能跑");
    }
}

/**
super:
 1.super调用父类属性
 2.super调用父类方法
 3.super调用父类构造方法
*/
public class Test1 {
    public static void main(String[] args) {
        Cat c = new Cat(3,"SANSAN");
        c.eat();
    }
}
class Pet{
    protected int age;
    protected String name;
    //public Pet() {}
    public Pet(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public void eat(){
        System.out.println("我能吃");
    }
}
class Cat extends Pet{
    public Cat(int age,String name){
        //调用父类构造方法(如果父类无参构造显示，则不需要用super调用)
        super(age,name);
    }
    public void sleep() {
        System.out.println("我能睡");
    }
    @Override
    public void eat() {
        //调用父类的方法
        super.eat();
        //super.属性  调用父类属性，如果继承了父类属性，super可省略
        System.out.println("我是"+super.name+"我"+super.age+"岁我能吃鱼");;
    }
}

/**
final关键字:
 1.使用final声明一个属性就是常量，常量一般都用大写表示,必须在定义时或在构造器中初始化
 2.使用final声明的方法只能被继承不能重写（最终方法）
 3.final声明的类不能被继承
 4.在方法参数中使用final，在该方法内部不能修改参数的值（内部类中详解）
*/
public class Test1 {
    public static void main(String[] args) {
        System.out.println(Constant.PERSON_NUM);
        Constant constant = new Constant();
        constant.printSize(3);
    }
}
//常量类（属于工具类）
class Constant{
    public static final int PERSON_NUM=10;//1
    public final void print(){//2
        System.out.println("final");
    }
    public void printSize(final int size){//4
        final int z=100;//4
        //size++;//无法操纵被final 声明的size
        //z++;//无法操纵被final 声明的z
        System.out.println(size);
        System.out.println(z);
    }
}
final class A{//3

}

/**
抽象类:用abstract关键字声明的类称为抽象类
1.抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
 2.非抽象类继承抽象类必须实现所有抽象方法
 3.抽象类可以继承抽象类，可以不实现父类抽象方法
 4.抽象类可以有方法实现和属性
 5.抽象类不能被实例化
 6.抽象类不能被声明为final
 7.抽象类可以有构造方法
*/
public class Test1 {
    public static void main(String[] args) {
        Man man = new Man();
        man.eat();
        man.move();
    }
}
abstract class Animal{
    public abstract void move();
}
abstract class Person extends Animal{
    public abstract void eat();
}
//继承抽象类的具体类必须实现抽象方法
class Man extends Person{
    @Override
    public void eat() {
        System.out.println("我爱吃肉");
    }

    @Override
    public void move() {
        System.out.println("我爱跑步");
    }
}

/**
接口
 1.在一个接口中，只能定义常量、抽象方法，JDK1.8后可定义默认的实现方法
 2.接口可继承多个接口，
 3.一个具体类实现接口用implements关键字，可实现多个接口
 4.抽象类实现接口可不实现接口方法
 5.接口中定义的方法没有声明访问修饰符默认是public
 6.接口不能有构造方法
 7.接口不能被实例化
*/
public class Test1 {
    public static void main(String[] args) {
        Girl zhang = new Girl("zhang");
        zhang.eat();
        zhang.print();
    }
}
interface IEat{
    //public abstract void eat();//接口中只能定义抽象方法
    void eat();//可简写，默认public abstract
    //public static final int NUM=10;//在接口中定义一个常量
    int NUM=10;//可简写
    //在JDK1.8后新特性，可被所有实现类继承（几乎不用）
    public default void print(){
        System.out.println("eat");
    }
}
interface IRun{
    void run();
}

interface ISleep extends IEat,IRun{//接口之间多继承
    void sleep();
}

class Girl implements ISleep,IEat{//类实现多个接口，必须实现所有方法
    private String name;
    public Girl() {}
    public Girl(String name) {
        this.name = name;
    }
    @Override
    public void sleep() {
        System.out.println("我爱睡觉");
    }
    @Override
    public void eat() {
        System.out.println("我是"+name+"，我爱吃饭");
    }
    @Override
    public void run() {
    }
}

/**
多态
 1.方法的重载与重写就是方法的多态性表现
 2.多个子类就是父类的多种形态
 3.父类引用可以指向子类对象自动转换
 4.子类对象指向父类引用需要强制转换（类型不对会报异常）
 5.在实际开发中尽量使用父类引用（更利于扩展（随意增加多种鸡类））
*/
public class Test1 {
    public static void main(String[] args) {
        //用父类的引用指向子类的对象（）自动转换（向上转型）
        Chicken hc = new HomeChicken("xiaoji");
        Chicken yc = new YeChicken("juji");
        Chicken jc = new JianjiaoChicken("jian");
        eat(hc);
        eat(yc);
        eat(jc);
    }
    //抽象（粒度）面向抽象编程（传入鸡类的实例调用同一个eat方法结果却不同）父类一般是抽象类或接口
    public static void eat(Chicken c){
        c.eat();
        //当需要把父类的实例强制转换为子类引用时，为避免类型转换异常，需要用instanceof判断
        if (c instanceof JianjiaoChicken) {//如果传入的c是JianjiaoChicken的实例那么转换
            JianjiaoChicken jc = (JianjiaoChicken) c;//大的类型转换为小类型，强制转换（向下转型）
            jc.song();
        }
    }
}
abstract class Chicken{
    private String name;
    public Chicken() {}
    public Chicken(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public abstract void eat();
}
class HomeChicken extends Chicken{
    public HomeChicken(String name) {
        super(name);
    }
    public void eat(){
        System.out.println(this.getName()+"，我爱吃米");
    }
}

class YeChicken extends Chicken{
    public YeChicken(String name) {
        super(name);
    }
    public void eat(){
        System.out.println(this.getName()+",我爱吃虫子");
    }
}
class JianjiaoChicken extends Chicken{
    public JianjiaoChicken(String name) {
        super(name);
    }
    public void eat(){
        System.out.println(this.getName()+",我不吃");
    }
    public void song(){
        System.out.println("jijiji");
    }
}