【java学习之路】（java SE篇）（讨论与思考）关于继承，封装，多态，接口的简单实现与思考

题目一

编写一个Person抽象类，要求含有姓名（name）年龄（age）两个私有属性以及吃饭（eat） 和睡觉（sleep）两个抽象方法，
并写出带参构造方法，创建学生（student）和工人（worker）

两个类，继承Person类，学生类多出了私有属性学号和学习方法（输出我爱学习）
工人类多出了私有属性工号和工作方法（输出我爱工作）

在主函数中创建学生和工人类 的实例对象，使用构造方法赋值，并输出所有属性和方法

代码：

person类

package Day01.Hw01;

public abstract class Person {

    private String name;
    private int age;

    public Person(){

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void eat();

    public abstract void sleep();
}

Student类

package Day01.Hw01;

public class Student extends Person{

    private int stuNum;

    public Student(String name, int age, int stuNum) {
        super(name, age);
        this.stuNum = stuNum;
    }

    @Override
    public void eat() {
        System.out.println("学生吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("学生睡觉");
    }

    public void learn(){
        System.out.println("我爱学习");
    }
}

Worker类

package Day01.Hw01;

public class Worker extends Person{

    private int workNum;

    public Worker(String name, int age, int workNum) {
        super(name, age);
        this.workNum = workNum;
    }

    @Override
    public void eat() {
        System.out.println("工人吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("工人睡觉");
    }

    public void work(){
        System.out.println("我爱工作");
    }
}

测试类

package Day01.Hw01;

public class Tset {
    public static void main(String[] args) {

        Student student = new Student("zs",20,1818014);
        Worker worker = new Worker("ww",50,8181510);

        student.eat();
        student.sleep();
        student.learn();

        worker.eat();
        worker.sleep();
        worker.work();

    }
}

运行截图

题目二

按要求编写一个Java应用程序：
(1)定义一个抽象类CanCry，描述会吼叫的方法public void cry()。
(2)分别定义狗类（Dog）和猫类（Cat），实现CanCry接口。
实现方法的功能分别为：打印输出“我是狗，我的叫声是汪汪汪”、“我是猫，我的叫声是喵喵喵”。
(3)定义一个主类Test
①定义一个void makeCry(CanCry c)方法，其中让会吼叫的动物吼叫。
②在main方法中创建狗类对象（dog）、猫类对象（cat）、Test类对象（t），用t调用makecry方法，让狗和猫吼叫。

代码
Cancry接口

package Day01.Hw02;

public interface Cancry {

    void cry();
}

Dog类

package Day01.Hw02;

public class Dog implements Cancry{
    @Override
    public void cry() {
        System.out.println("我是狗，我的叫声是汪汪汪");
    }
}

Cat类

package Day01.Hw02;

public class Cat implements Cancry{
    @Override
    public void cry() {
        System.out.println("我是猫，我的叫声是喵喵喵");
    }
}

Test类

package Day01.Hw02;

public class Test {

    public void makeCry(Cancry c){
        c.cry();
    }

    public static void main(String[] args) {
        Cancry dog = new Dog();
        Cancry cat = new Cat();

        Test t = new Test();
        t.makeCry(dog);
        t.makeCry(cat);
    }
}

运行截图

总结

1.继承

/*
* 继承：
*   表示父类跟子类之间的关系（is-a）
*   当两个类或者多个类具备相同的属性和方法的时候，可以提取出来，变成父类，子类可以继承
*   使用时  extend  关键字
*   注意：java中是单继承关系
*
*   super: 是 直接父类  对象的引用
*   用途：
*       1.可以在子类中调用父类中被子类覆盖的方法  super.父类方法名称
*       2.当super在普通方法中使用时，可以任意位置编写
*       3.当super在构造方法中使用，会调用父类的构造方法，一定要把super放在第一行
*       4.在构造方法中，super（）和this（）不能同时出现
*       5.父类中的私有属性和方法都不能被调用
*       6.子类构造方法中都会默认使用super关键字调用父类的无参构造方法
*         因此在定义类的时候，无论自己是否有其他构造方法，最好将无参构造方法写上
*       7.如果构造方法中显式的指定了super构造方法，那么无参构造方法就不会被调用
*
*   总结：
*       1.在创建子类对象的时候一定会优先创造父类对象
*       2.所有的java类都具备一个老祖宗类，称之为Object
*/

2.封装

/*
* 定义类的时候需要包含以下组件：
*   私有属性
*   构造方法（无参构造方法和自定义构造方法）
*   set/get方法
*   普通方法
*
* */
/*
* 封装的概念：
*   将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
*
* 封装解决什么问题？
*   如果任何一个处理类都可以对类进行赋值操作，那么当值不准确时，可能会产生不准确的结果
*   如何在赋值时添加一些逻辑判断
*
*封装的作用
*   使用封装可以保证数据的规范，不符合规范的数据将无法进行操作
*
* 封装的好处：
*   1.隐藏类的实现细节
*   2.只能通过提供的方法进行访问
*   3.可以根据需求添加复杂的逻辑判断语句
*   4.方便修改实现
* */

3.多态

//父类的引用指向子类对象
        /*
            编译期间：写代码是就是编译期，Animal dog在编译期间是Animal类型
            运行期间：run运行程序，Animal dog在运行期间是Dog类型

            对于成员方法：编译看左边，运行看右边
            对于静态方法，成员变量：编译和运行都看左边

            多态的好处：提高了程序的扩展性
            多态的不足：无法调用子类中特有的方法
                解决方法：类型强制转换【有风险】
                风险解决方法：做一个判断instanceof
                if（animal instanceof Dog）{
                    Dog dog = (dog)animal;
                    dog.play;
                }

            instanceof
                测试一个对象是否为一个类的实例

         */

4.接口

/*
* java中的继承关系是单继承，如果拥有多个父类的时候，可以考虑使用接口实现
*   java中的接口具备广泛的使用：
*   用法：
*       使用interface来修饰
*       接口中可以包含多个方法，且方法跟抽象类的抽象方法一致，可以不写实现，子类在实现的时候必须要实现代码逻辑
*       子类实现接口使用implements关键字
*   特征：
*       1.接口中的所有方法都是抽象方法，不能包含方法的实现
*       2.接口中的所有方法的访问权限都是public
*       3.接口不能被实例化
*       4.接口的子类必须要实现接口中的所有方法，跟抽象类有所不同，抽象类中的抽象方法才必须要被子类实现
*       5.子类可以拥有多个接口
*       6.接口中的变量都是静态常量
*       7.接口中的方法和常量无论是否添加public修饰，默认的权限只有一个public（有且仅有）
*
*   接口的使用：
*       1.接口中可以定义无数个方法，子类在进行实现的时候，必须要实现这些方法，将这些方法进行实现，就意味着具备了方法的能力
*       (接口代表了实力的一种能力，只要被定义，对应的实例就一定具备这种能力）
*
*	抽象类和接口的区别：
*		1.抽象类中的方法可以有抽象方法也可以有普通方法，但是接口中只能有抽象方法
*		2.抽象类需要使用abstract关键字修饰，而接口需要interface关键字修饰
*		3.子类使用extends关键字来继承抽象类，使用implements来实现接口
*		4.子类继承抽象类的时候必须要实现所有的抽象方法，普通方法可以不重写，而接口中的所有方法必须要重写
*		5.抽象类中可以定义成员变量，而接口中只能定义静态常量
*		6.抽象类在子类实现的时候是单继承，而接口是多继承
*		7.抽象类和接口都不能实例化，但是抽象类中可以有构造方法，而接口中不能有
* */