编程语言
首页 > 编程语言> > 【java学习之路】(番外)关于继承,封装,多态,接口的简单实现与思考

【java学习之路】(番外)关于继承,封装,多态,接口的简单实现与思考

作者:互联网

题目一

编写一个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.抽象类和接口都不能实例化,但是抽象类中可以有构造方法,而接口中不能有
* */

标签:java,构造方法,子类,番外,多态,接口,void,方法,public
来源: https://blog.csdn.net/qq_24254611/article/details/122583870