Java打卡1

猫和狗案例

案例结构

package com.Java11;

/**
 *  接口类
 */
public interface java11 {
    public abstract void jump();
}

package com.Java11;

/**
 *  狗类 同样继承抽象动物类，重写接口类方法
 */
public class Dog extends Animal implements java11{
    // 生成无参构造方法和带参构造方法
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    // 重写接口类的方法
    @Override
    public void eat() {
        System.out.println("狗的吃方法");
    }

    @Override
    public void jump() {
        System.out.println("狗的跳高方法");
    }
}

package com.Java11;

/**
 *  猫类  继承抽象动物类，重写接口类方法
 */
public class Cat extends Animal implements java11 {
    // 生成无参构造方法和带参构造方法

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    // 重写吃的方法
    @Override
    public void eat() {
        System.out.println("猫的吃方法");
    }

    // 重写跳高的方法
    @Override
    public void jump() {
        System.out.println("猫的挑高方法");
    }
}

package com.Java11;

/**
 *  抽象动物类
 */
public abstract class Animal {
    public String name;
    public int age;

    // 无参构造方法
    public Animal() {
    }

    // 带参构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter setter方法
    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 abstract void eat();
}

 

package com.Java11;

/**
 *  测试类
 */
public class javaDemo11 {
    public static void main(String[] args) {
        // java11接口创建的，只能调用java11类里面的方法
        java11 j = new Cat();
        j.jump(); // 猫的跳高方法
        System.out.println("----------");

        // 用Animal创建对象，只能调用Animal类里面的方法
        Animal Cat = new Cat();
        Cat.setName("加菲猫");
        Cat.setAge(5);
        Cat.eat(); // 猫的吃方法
        System.out.println(Cat.getName()); // 加菲猫
        System.out.println(Cat.getAge()); // 5
        System.out.println("----------");

        // 来试试用带参构造方法创建对象
        Animal a = new Cat("加菲", 5);
        System.out.println(a.getName()); // 加菲
        System.out.println(a.getAge()); // 5
        a.eat(); // 猫的吃方法
        System.out.println("----------");

        // 上面的使用是比较麻烦的，可以直接使用Cat类创建对象
        Cat aa = new Cat();
        aa.setName("加菲毛毛毛");
        aa.setAge(7);
        System.out.println(aa.getName()); // 加菲毛毛毛
        System.out.println(aa.getAge());  // 7
        aa.eat(); // 猫的吃方法
    }
}

类和接口之间的关系

文件结构

package com.Java12;

/**
 *  接口1
 *  接口和接口之间是可以继承，一个接口可以继承多个接口
 */
public interface Java12_1 extends Java12_2,Java12_3 {
}

package com.Java12;

/**
 *  接口2
 */
public interface Java12_2 {
}

package com.Java12;

/**
 *  接口3
 */
public interface Java12_3 {
}

package com.Java12;

/**
 *  实现接口的类，一个类可以同时实现多个接口，这里默认继承了Object的类
 */
public class Java12 extends Object implements Java12_1,Java12_2,Java12_3 {
}

类和类是继承关系，只能单继承，但是可以多层继承

类和接口是实现关系，可以单实现，也可以多实现，还可以继承一个类再实现多个接口

接口和接口是继承关系，可以单继承，也可以多继承

千万不要把类和接口当做男人女人理解

抽象类和接口之间的区别

抽象类：对类抽象，包括属性、行为（方法）

接口： 对行为抽象，主要是行为（方法）

门和报警的例子

package com.Java13;

/**
 *  报警接口
 */
public interface Alarm {
    // 声明一个报警方法
    void alarm();
}

package com.Java13;

/**
 *  门的抽象类
 */
public abstract class Door {
    // 抽象类方法
    public abstract void open();
    public abstract void close();
}

package com.Java13;

/**
 *  报警门类，继承门的抽象类，实现报警的接口
 */
public class AlarmDoor extends Door implements Alarm {
    // 重写抽象类方法，实现接口

    @Override
    public void open() {
        System.out.println("报警门开了");
    }

    @Override
    public void close() {
        System.out.println("报警门关闭了");
    }

    @Override
    public void alarm() {
        System.out.println("报警门报警了");
    }
}

package com.Java13;

/**
 *  测试类
 */
public class JavaDemo13 {
    public static void main(String[] args) {
        // 直接用AlarmDoor创建对象
        AlarmDoor D = new AlarmDoor();
        D.open(); // 报警门开了
        D.close(); // 报警门关闭了
        D.alarm(); // 报警门报警了
    }
}

工作原因，每天一小时打卡，坚持