Java中继承和抽象类的使用

Dear 丶 2024-04-01 12:51 63阅读 0赞

### 匿名对象 ###

匿名对象顾名思义就是没有名字的对象，如果我们创建了一个对象但是在左边没有用变量接收这个对象，那么就是一个匿名对象。
    比如创建对象的格式：
    	数据类型 对象名 = new 数据类型();
    如果上面格式只写了右边，没有写左边，那么就是一个匿名对象。
    
    好处：
    	匿名对象可以稍微简化我们的操作。
    
    匿名对象的使用场景：
        1. 如果某个对象我们只需要用一次，那么可以使用匿名对象【匿名对象没有接受，用完之后就找不到了】
        2. 当做方法参数进行传递。

**测试类**

public class Demo01NoName {
        
        public static void main(String[] args) {
        
            //创建Student对象
            //Student stu = new Student();
            //创建完对象调用eat方法
            //stu.eat();
    
            //使用匿名对象调用eat方法
            //new Student().eat();
    
            //创建集合，用来保存学生
            ArrayList<Student> list = new ArrayList<>();
    
            //添加学生
            list.add(new Student("张三", 13));
            list.add(new Student("李四", 14));
            list.add(new Student("王叔叔", 50));
    
            //遍历输出
            for (int i = 0; i < list.size(); i++) {
        
                Student stu = list.get(i);
                System.out.println(stu.getName() + "-" + stu.getAge());
            }
    
        }
    }

**Student类**

public class Student {
        
        private String name;
        private int age;
    
        //睡觉
        public void sleep() {
        
            System.out.println("睡觉觉");
        }
    
        //吃
        public void eat() {
        
            System.out.println("吃饭饭");
        }
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        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;
        }
    }

### 继承 ###

#### 为什么使用继承 ####

![在这里插入图片描述][ee7bfbce6eb24fc58c4f3c8e03cf7b43.png]

#### 继承的代码【重点】 ####

**Employee**

/*
        我们可以将多个类（子类）中的共性向上抽取，抽取到另一个类（父类）中。
        子类继承父类，会自动拥有父类所有的成员（私有成员也能继承，不过无法直接访问）
    
        继承的格式：
            public class A {}
            public class B extends A {}
            上面代码表示B类继承了A类，B是子类，A是父类，B类会自动拥有A类所有的成员。
    
    
     */
    public class Employee {
        
        //姓名
        String name;
        //年龄
        int age;
    }

**Teacher**

/*
        讲师类
     */
    public class Teacher extends Employee{
        
        //讲课方法
        public void teach() {
        
            System.out.println("讲师讲课");
        }
    }

**Assistant**

public class Assiatant extends Employee{
        
        //辅导方法
        public void help() {
        
            System.out.println("助教辅导");
        }
    }

**Demo01Test**

/*
        测试类
     */
    public class Demo01Test {
        
        //定义main方法
        public static void main(String[] args) {
        
            //创建讲师对象
            Teacher t = new Teacher();
            //给讲师对象的属性赋值
            t.name = "小明老师";
            t.age = 30;
            System.out.println("姓名：" + t.name + "，年龄：" + t.age);
            //调用方法
            t.teach();
    
        }
    }

#### 继承中成员变量的特点【了解】 ####

**Demo01Test**

/*
        继承关系中成员变量的访问特点：
            通过子类访问成员，子类没有，会向上找父类。
            通过父类访问成员，父类没有，不会向下找子类。
    
        父类和子类成员变量同名时的访问特点（了解）：
            直接访问（通过子类对象直接访问）：
                使用的是子类自己的成员。
            间接访问（通过方法的方式去访问）
                调用的是哪个类中的方法，访问到的就是哪个类中的成员变量。
     */
    public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建子类对象
            //Zi zi = new Zi();
            //访问属性
            //System.out.println(zi.numZi);//10
            //System.out.println(zi.numFu);//20
    
            //创建父类对象
            //Fu fu = new Fu();
            //访问属性
            //System.out.println(fu.numZi);
            //System.out.println(fu.numFu);//20
    
            //创建子类对象
            Zi zi = new Zi();
            //输出属性值
            //System.out.println(zi.num);
            //调用方法
            zi.showZi();
            zi.showFu();
        }
    }

**Fu**

public class Fu {
        
        int numFu = 20;
    
        int num = 20;
    
        //定义成员方法，用来输出num的值
        public void showFu() {
        
            System.out.println(num);
        }
    }

**Zi**

public class Zi extends Fu{
        
        int numZi = 10;
    
        int num = 10;
    
        //定义方法，用来输出num
        public void showZi() {
        
            System.out.println(num);
        }
    }

#### 继承中成员方法的特点(重写)【重点】 ####

**Demo01Test**

/*
        继承中成员方法的访问特点
            如果子类中的成员方法和父类中的成员方法同名，那么通过子类对象访问成员方法，访问的是子类中定义的成员方法。
    
    
        如果子类中出现了和父类一模一样的方法，那么这个就叫做方法的重写。
        重写和重载的区别：
            重载： 方法名，参数列表不同。
            重写： 在子类中出现了和父类一模一样的方法。
    
     */
    public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建子类对象
            Zi zi = new Zi();
            zi.methodZi();
            zi.methodFu();
            zi.method();//运行的是子类中定义的method方法
        }
    }

**Fu**

public class Fu {
        
        public void methodFu() {
        
            System.out.println("methodFu方法");
        }
    
        public void method() {
        
            System.out.println("父类的method方法");
        }
    }

**Zi**

public class Zi extends Fu{
        
        public void methodZi() {
        
            System.out.println("methodZi方法");
        }
    
        public void method() {
        
            System.out.println("子类的method方法");
        }
    }

#### 方法重写的注意事项【了解】 ####

**Demo01Test**

/*
        方法重写的注意事项：
            1. 子类在重写父类方法时，参数列表必须相同。
            2. 子类重写父类方法时，子类方法的权限一定要大于等于父类方法的权限【了解】
                    public > protected > 默认 > private
                    默认权限指的是省略不写，如果省略权限修饰符，那么方法就是默认权限。
            3. 私有的方法不能被重写
    
    
        一般来说，方法重写时，权限修饰符，返回值类型都是一致的。
     */
    public class Demo01Test {
        
    }

**Fu**

public class Fu {
        
        //定义方法
        public void method() {
        
            System.out.println("父类的method方法执行了");
        }
    }

**Zi**

public class Zi extends Fu{
        
        /*
            @Override 叫做注解
            这个注解的作用是用来验证一个方法是否是重写父类的方法。
            我们可以在一个方法上面加上@Override注解，如果在方法上面加上该注解报错，那么表示该方法不是重写父类的方法。
            如果在方法上面加上该注解不报错，那么说明该方法是重写父类的方法。
         */
        @Override
        public void method() {
        
            System.out.println("子类的method方法执行了");
        }
    }

#### 方法重写的应用【重要】 ####

![在这里插入图片描述][97fe175d81c54af9b45c6d67a2d5aacb.png]

**Phone**

/*
        手机类
     */
    public class Phone {
        
        //打电话
        public void call() {
        
            System.out.println("打电话");
        }
    
        //发短信
        public void sendMessage() {
        
            System.out.println("发短信");
        }
    
        //来电显示
        public void show() {
        
            System.out.println("显示号码");
        }
    }

**NewPhone**

/*
        新手机类
            来电显示不仅可以显示号码，还可以显示归属地，头像， 姓名
     */
    public class NewPhone extends Phone{
        
        //重写父类的show方法，在show方法中定义更强大的来电显示的内容
        //ctrl + o
        @Override
        public void show() {
        
            //如果想要在子类中调用父类的方法，可以及使用super关键字
            super.show();//调用的父类的show方法。
            System.out.println("显示姓名");
            System.out.println("显示头像");
            System.out.println("显示归属地");
        }
    }

**Demo01Test**

public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建新手机对象
            NewPhone np = new NewPhone();
            //调用方法
            np.call();
            np.sendMessage();
            np.show();
        }
    }

#### 继承中的构造方法【重要】 ####

**Demo01Test**

/*
        在继承关系中构造方法的注意事项：
            1. 构造方法不能继承。
            2. 创建子类对象时会先执行父类的构造方法，然后执行子类的构造方法。 原因是因为在子类构造方法的第一句有一个隐藏的super()，是在调用父类的空参数构造方法
            3. 我们也可以使用super关键字手动调用父类的构造方法。
                super(参数)
            4. 如果使用super调用构造方法，那么只能放在第一行。
    
     */
    public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建子类对象
            Zi zi = new Zi();
        }
    }

**Fu**

public class Fu {
        
        //定义空参数的构造方法
        public Fu() {
        
            System.out.println("父类空参数的构造方法执行了");
        }
    
        //定义带参数的构造方法
        public Fu(String str) {
        
            System.out.println("父类一个参数是字符串的构造方法执行了" + str);
        }
    }

**Zi**

public class Zi extends Fu{
        
        public Zi() {
        
            //super(); 在调用父类空参数的构造方法
            //super();
            super("hello");
            System.out.println("子类空参数的构造方法执行了");
        }
    }

#### super的三种用途【重要】 ####

**Demo01Test**

/*
        super的三种用途
            1. 可以访问父类的成员变量。
                super.成员变量
            2. 可以访问父类的成员方法
                super.成员方法()
            3. 可以访问父类的构造方法
                super();
     */
    public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建子类对象
            Zi zi = new Zi();
            zi.show();
        }
    }

**Fu**

public class Fu {
        
        int num = 20;
    
        public void method() {
        
            System.out.println("父类的method方法");
        }
    
        public Fu() {
        
    
        }
    
        public Fu(String str) {
        
            System.out.println("父类一个参数是字符串的构造方法执行了：" + str);
        }
    }

**Zi**

public class Zi extends Fu{
        
        int num = 10;
    
        public Zi() {
        
            //调用父类一个参数是字符串的构造方法
            super("hello");
        }
    
        //定义show方法
        public void show() {
        
            System.out.println(super.num);
            super.method();
        }
    
        public void method() {
        
            System.out.println("子类的method方法");
        }
    }

#### this的三种用途【重要】 ####

**Demo01Test**

/*
        this的三种用途：
            1. 可以访问本类中的成员变量。
                this.成员变量
            2. 可以访问本类中的成员方法
                this.成员方法()
            3. 可以访问本类中的构造方法。
                this(参数);
                如果this调用构造方法，也必须放在第一行
     */
    public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建子类对象
            Zi zi = new Zi();
            //zi.show();
        }
    }

**Fu**

public class Fu {
        
        int num = 30;
    
        //提供空参数的构造方法
        public Fu() {
        
            System.out.println("父类空参数的构造方法执行了");
        }
    
        public void method() {
        
            System.out.println("父类的method方法执行了");
        }
    }

**Zi**

public class Zi extends Fu{
        
        int num = 20;
    
        public Zi() {
        
            //使用this关键字调用本类其他的构造方法
            this("hello");
            System.out.println("子类空参数的构造方法执行了");
        }
    
        public Zi(String str) {
        
            this(100);
            System.out.println("子类一个参数是字符串的构造方法执行了：" + str);
        }
    
        public Zi(int num) {
        
            System.out.println("子类一个参数是int的构造方法执行了：" + num);
        }
    
        //定义show方法
        public void show() {
        
            //int num = 10;
            //System.out.println(this.num);
    
            this.method();
        }
    
        public void method() {
        
            System.out.println("子类的method方法执行了");
        }
    }

#### this和super的内存图 ####

![在这里插入图片描述][419195f0e2194d6c812e67d033fa1aa5.png]

#### Java中继承的特点【重要】 ####

![在这里插入图片描述][aac865e0561048a0a8f187a28f0c9c2a.png]

### 抽象类 ###

#### 抽象的介绍 ####

![在这里插入图片描述][2a18fa5a51ae4e4781e4470f3c3ca293.png]

#### 抽象类的定义和使用【重要】 ####

**Animal**

/*
        动物类。
        动物有吃的行为，但是动物吃什么，我们是说不清的， 这种说不清道不明的方法，我们可以定义成抽象方法。
    
        抽象方法：
            使用abstract修饰，没有方法体。
        抽象方法格式：
            public abstract 返回值类型 方法名(参数);
    
        抽象类：
            抽象方法存在的类必须是一个抽象类。抽象类就是使用abstract修饰的类。
    
        抽象类的格式：
            public abstract class 类名 {}
    
        抽象类的使用：
            1. 抽象类不能创建对象。
            2. 抽象类是给子类用的，我们要定义一个子类去继承抽象类。
            3. 重写抽象类中的所有的抽象方法。
            4. 创建子类对象，通过子类对象调用方法。
    
     */
    public abstract class Animal {
        
        /*
            定义吃的方法
         */
        public abstract void eat();
    
    }

**Cat**

/*
        猫类
     */
    public class Cat extends Animal{
        
        @Override
        public void eat() {
        
            System.out.println("猫吃鱼");
        }
    }

**Dog**

/*
        狗类
     */
    public class Dog extends Animal{
        
        public void eat() {
        
            System.out.println("狗吃骨头");
        }
    }

**测试类**

/*
        测试类
     */
    public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建Animal子类对象
            Cat cat = new Cat();
            cat.eat();
        }
    }

#### 抽象类的注意事项 ####

**Demo01Test**

/*
        抽象类的注意事项：
            1. 抽象类不能创建对象
            2. 抽象类中也是有构造方法的，抽象类中的构造方法是给子类用的。
            3. 抽象类中可以有抽象方法，也可以有非抽象的方法。
               抽象方法所在的类必须是一个抽象类。
            4. 一个普通类在继承抽象类时，必须重写这个抽象类中所有的抽象的方法。
               一个抽象类在继承抽象类时，可以不重写抽象类中的抽象方法。
            5. 抽象类的目的是为了让子类继承，体现的是模板思想。
     */
    public class Demo01Test {
        
        public static void main(String[] args) {
        
            Zi zi = new Zi();
        }
    }

**AbstractFu**

public abstract class AbstractFu {
        
        //提供空参数的构造方法
        public AbstractFu() {
        
            System.out.println("空参数的构造方法执行了");
        }
        //定义普通方法
        public void normalMethod() {
        
            System.out.println("抽象类中普通的方法");
        }
    
        public abstract void abstractMethod();
    
        public abstract void abstractMethod2();
    
    
    }

**AbstractZi**

public abstract class AbstractZi extends AbstractFu{
        
    
    }

**Zi**

public class Zi extends AbstractFu{
        
        @Override
        public void abstractMethod() {
        
            System.out.println("重写后的abstractMethod");
        }
    
        @Override
        public void abstractMethod2() {
        
            System.out.println("重写后的abstractMethod2");
        }
    }

**SunZi**

public class SunZi extends AbstractZi{
        
    
        @Override
        public void abstractMethod() {
        
    
        }
    
        @Override
        public void abstractMethod2() {
        
    
        }
    }

### final关键字 ###

#### final修饰类，方法，变量 ####

如果final修饰类，这个类不能被继承，但是这个类可以继承其他类。
    如果final修饰方法，这个方法不能被重写，但是可以被子类继承使用。
    如果final修饰变量，这个变量的值不能被改变，从效果上看，这个变量也就变成了常量。
        如果final修饰的是局部变量，那么变量的值只能赋值一次，一旦赋值就不能更改了。
        如果final修饰的是成员变量，该变量也是只能赋值一次，一旦赋值不能更改。
        final修饰的成员变量，必须在创建对象之前完成赋值（可以直接赋值，也可以构造方法中赋值）
    
    常量的命名规范：所有字母都大写，如果有多个单词，多个单词之间使用下划线隔开。比如： AAA_BBB_CCC

[ee7bfbce6eb24fc58c4f3c8e03cf7b43.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b8ab4ec08ab8498483a2f1fd2910b5b3.png
[97fe175d81c54af9b45c6d67a2d5aacb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/32ab4f2fe93a4c29b2536059bcfda6d4.png
[419195f0e2194d6c812e67d033fa1aa5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b04c84d08e4540498a563b0dfb258fb0.png
[aac865e0561048a0a8f187a28f0c9c2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/65b83e5d431f4c29bf379da3e57537f0.png
[2a18fa5a51ae4e4781e4470f3c3ca293.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/4b6852af235b405eaf54c6f50caff453.png