【day010】Java学习，坚持就是胜利！

最新推荐文章于 2024-05-02 09:27:17 发布
最新推荐文章于 2024-05-02 09:27:17 发布
阅读量263 收藏
点赞数 1
文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38592706/article/details/108457025
版权

一、多态的格式与使用

package cn.itcast.day10.demo04;

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

    public void methodFu() {
        System.out.println("父类特有方法");
    }
}


package cn.itcast.day10.demo04;

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


package cn.itcast.day10.demo04;

/*
代码当中体现多态性，其实就是一句话：父类引用指向子类对象。

格式：
父类名称 对象名 = new 子类名称();
或者：
接口名称 对象名 = new 实现类名称();
 */
public class Demo01Multi {
    public static void main(String[] args) {
        // 使用多态的写法
        // 左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();

        obj.method();
        obj.methodFu();

    }
}
/*
子类方法
父类特有方法
*/

二、多态中成员变量的使用特点

package cn.itcast.day10.demo05;

public class Fu {
    int num = 10;

    public void showNum() {
        System.out.println(num);
    }
}

package cn.itcast.day10.demo05;

public class Zi extends Fu {
    int num = 20;
    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }
}


package cn.itcast.day10.demo05;
/*
访问成员变量的两种方式：
1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
*/
public class Demo01MultiField {

    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num); // 父：10
//        System.out.println(obj.age); // 错误写法！
        System.out.println("========================");
        // 子类没有覆盖重写，就是父：10
        // 子类覆盖重写，就是子：20
        obj.showNum();

     }
}

三、多态中成员方法的使用特点

package cn.itcast.day10.demo05;

public class Fu {
    int num = 10;

    public void showNum() {
        System.out.println(num);
    }

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

    public void methodFu() {
        System.out.println("父类特有方法");
    }
}


package cn.itcast.day10.demo05;

public class Zi extends Fu {
    int num = 20;
    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }

    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodZi() {
        System.out.println("子类特有的方法");
    }
}


package cn.itcast.day10.demo05;
/*
在多态的代码当中，成员方法的访问规则是：
    看new的是谁，就优先用谁，没有则向上找。

口诀：编译看左边，运行看右边。

对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。
*/
public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi(); // 多态

        obj.method(); // 父子都有，优先用子
        obj.methodFu(); // 子类没有，父类有，向上找到父类

        // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
//        obj.methodZi(); // 错误写法！

    }
}
/*
子类方法
父类特有方法
*/

四、使用多态的好处

在这里插入图片描述

五、对象的向上转型

在这里插入图片描述

package cn.itcast.day10.demo06;

public abstract class Animal {
    public abstract void eat();
}

package cn.itcast.day10.demo06;

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

package cn.itcast.day10.demo06;

public class Demo01Main {
    public static void main(String[] args) {
        // 对象的向上转型，就是：父类引用指向子类对象。
        Animal animal = new Cat();
        animal.eat();
    }
}
/*
猫吃鱼
*/

六、对象的向下转型

在这里插入图片描述

package cn.itcast.day10.demo06;

public abstract class Animal {
    public abstract void eat();
}


package cn.itcast.day10.demo06;

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

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}


package cn.itcast.day10.demo06;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃SHIT");
    }

    public void watchHouse() {
        System.out.println("狗看家");
    }
}


package cn.itcast.day10.demo06;
/*
向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案：用对象的向下转换【还原】。

*/
public class Demo01Main {
    public static void main(String[] args) {
        // 对象的向上转型，就是：父类引用指向子类对象。
        Animal animal = new Cat(); // 本来创建的时候是一只猫
        animal.eat(); // 猫吃鱼

//        animal.catchMouse(); // 错误写法！

        // 向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠


        // 下面是错误的向下转型
        // 本来new的时候是一只猫，现在费用当作狗
        // 错误写法！编译不会报错，但是运行会出现异常：
        // java.lang.ClassCastException，类型转换异常
//        Dog dog = (Dog) animal;

    }
}
/*
猫吃鱼
*/

七、用isinstanceof关键字进行类型判断

package cn.itcast.day10.demo06;

/*
如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。
*/
public class Demo02Instanceof {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 本来是一只狗
        animal.eat(); // 狗吃SHIT

        // 如果希望调用子类特有的方法，需要向下转型
        // 判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        // 判断一下animal本来是不是Cat
        if(animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if(animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}
/*
狗吃SHIT
狗看家
*/

八、笔记本USB接口案例_分析

在这里插入图片描述

在这里插入图片描述

九、笔记本USB接口案例_实现

package cn.itcast.day10.demo07;

public interface USB {

    public abstract void open(); // 打开设备

    public abstract void close(); // 关闭设备

}


package cn.itcast.day10.demo07;

public class Computer {
    public void powerOn() {
        System.out.println("笔记本开机");
    }

    public void powerOff() {
        System.out.println("笔记本关机");
    }

    // 使用USB设备的方法，使用接口作为方法的参数
    public void usbDevice(USB usb) {
        usb.open(); // 打开设备
        if (usb instanceof Mouse) { // 一定要先判断
//            ((Mouse) usb).click();
            Mouse mouse = (Mouse) usb; // 向下转型
            mouse.click();
        } else if (usb instanceof Keyboard) { // 先判断
//            ((Keyboard) usb).type();
            Keyboard keyboard = (Keyboard) usb; // 向下转型
            keyboard.type();
        }
        usb.close(); // 关闭设备
    }
}


package cn.itcast.day10.demo07;

// 键盘就是一个USB设备
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}


package cn.itcast.day10.demo07;

// 键盘就是一个USB设备
public class Keyboard implements USB {
    @Override
    public void open() {

        System.out.println("打开键盘");
    }

    @Override
    public void close() {

        System.out.println("关闭键盘");
    }

    public void type() {
        System.out.println("键盘输入");
    }
}


package cn.itcast.day10.demo07;

public class DemoMain {
    public static void main(String[] args) {
        // 首先创建一个笔记本电脑
        Computer computer = new Computer();
        computer.powerOn();

        // 准备一个鼠标，供电脑用
        Mouse mouse = new Mouse();
        // 首先进行向上转型
        USB usbMouse = new Mouse(); // 多态写法
        //参数是USB类型，我正好传递进去的就是USB鼠标
        computer.usbDevice(usbMouse);


        // 创建一个USB键盘
        Keyboard keyboard = new Keyboard(); // 没有使用多态写法
        // 方法参数是USB类型，传递进去的是实现类对象
        computer.usbDevice(keyboard); // 正确写法！也发生了向上转型
        // 使用子类对象，匿名对象，也可以
//        computer.usbDevice(new Keyboard()); // 也是正确写法


        computer.powerOff();
        System.out.println("===============================");

        method(10.0); // 正确写法，double --> double
        method(20); // 正确写法， int --> double
        int a = 30;
        method(a); // 正确写法，int --> double
    }

    public static void method(double num) {
        System.out.println(num);
    }
}
/*
笔记本开机
打开鼠标
鼠标点击
关闭鼠标
打开键盘
键盘输入
关闭键盘
笔记本关机
===============================
10.0
20.0
30.0
*/

十、final关键字概念与四种用法

package cn.itcast.day11.demo01;
/*
final关键字代表最终、不可改变的。

常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量
*/
public class Demo01Final {
}

十一、final关键字用于修饰类

package cn.itcast.day11.demo01;

/*
当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {
    // ...
}

含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）
*/
public final class MyClass {
    public void method() {
        System.out.println("方法执行！");
    }
}


package cn.itcast.day11.demo01;

// 不能使用一个final类来作为父类
public class MySubClass /*extends MyClass*/{
}

十二、final关键字用于修饰成员方法

package cn.itcast.day11.demo01;

/*
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表) {
    // 方法体
}

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
*/

public abstract class Fu {

    public final void method() {
        System.out.println("父类方法执行！");
    }

    public abstract /*final*/ void methodAbs();
}


package cn.itcast.day11.demo01;

public class Zi extends Fu {
    @Override
    public void methodAbs() {

    }

//    @Override
//    public void method() {
//        System.out.println("子类方法执行！");
//    }


}

十三、final关键字用于修饰局部变量

package cn.itcast.day11.demo01;

public class Student {
    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package cn.itcast.day11.demo01;
/*
final关键字代表最终、不可改变的。

常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量
*/
public class Demo01Final extends Student {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        num1 = 20;
        System.out.println(num1); // 20

        // 一旦使final用来修饰局部变量，那么这个变量就不能进行更改。
        // “一次赋值，终生不改”
        final int num2 = 200;
        System.out.println(num2); // 200

//        num2 = 250; // 错误写法！不能改变！
//        num2 = 200; // 错误写法!

        // 正确写法！只要保证有唯一一次赋值即可
        final int num3;
        num3 = 30;

        // 对于基本类型来说，不可变说的是变量当中的数据不可改变
        // 对于引用类型来说，不可变说的是变量当中的地址值不可改变
        Student stu1 = new Student("赵丽颖");
        System.out.println(stu1);
        System.out.println(stu1.getName()); // 赵丽颖
        stu1 = new Student("霍建华");
        System.out.println(stu1);
        System.out.println(stu1.getName()); // 霍建华
        System.out.println("======================");

        final Student stu2 = new Student("高圆圆");
        // 错误写法！final的引用类型变量，其中的地址不可改变
//        stu2 = new Student("赵又廷");
        System.out.println(stu2.getName()); // 高圆圆
        stu2.setName("高圆圆圆圆圆圆");
        System.out.println(stu2.getName()); // 高圆圆圆圆圆圆

    }
}
/*
10
20
200
cn.itcast.day11.demo01.Student@75412c2f
赵丽颖
cn.itcast.day11.demo01.Student@282ba1e
霍建华
======================
高圆圆
高圆圆圆圆圆圆
*/

十四、final关键字用于修饰成员变量

package cn.itcast.day11.demo01;

/*
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3. 必须保证类当中所有 重载的构造方法，都最终会对final的成员变量进行赋值。
*/
public class Person {
    private final String name /* = "鹿晗"*/;

    public Person() {
        name = "关晓彤";
    }

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

    public String getName() {
        return name;
    }

//    public void setName(String name) {
//        this.name = name;
//    }
}

十五、四种权限修饰符

package cn.itcast.day11.demo02;
/*
Java中有四种权限修饰符：
                             public     >     protected     >     (default)     >     private
同一个类（我自己）               YES               YES                 YES                 YES
同一个包（我邻居）               YES               YES                 YES                  NO
不同包子类（我儿子）             YES               YES                  NO                  NO
不同包非子类（陌生人）           YES                NO                  NO                  NO

注意事项：（default）并不是关键字“default”，而是根本不写。
*/
public class Demo01Main {
}


package cn.itcast.day11.demo02;

public class MyClass {

    public int num = 10;

    public void method() {
        System.out.println(num);
    }
}


package cn.itcast.day11.demo02;

public class MyAnother {
    public void anotherMethod() {
        System.out.println(new MyClass().num);
    }
}


package cn.itcast.day11.demo02.sub;

import cn.itcast.day11.demo02.MyClass;

public class MySon extends MyClass {

    public void methodSon() {
        System.out.println(super.num);
    }
}


package cn.itcast.day11.demo02.sub;

        import cn.itcast.day11.demo02.MyClass;

public class Stranger {

    public void methodStranger() {
        System.out.println(new MyClass().num);
    }
}

十六、内部类的概念与分类

package cn.itcast.day11.demo03;

/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：
1. 成员内部类
2. 局部内部类（包含匿名内部类）
*/
public class Demo01InnerClass {
}

十七、成员内部类的定义

在这里插入图片描述
在这里插入图片描述

package cn.itcast.day11.demo03;

/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：
1. 成员内部类
2. 局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符 class 外部类名称 {
    修饰符 class 内部类名称 {
        // ...
    }
    // ...
}

注意：内用外，随意访问；外用内，需要内部类对象。

*/
public class Demo01InnerClass {
}


package cn.itcast.day11.demo03;

public class Body { // 外部类

    public class Heart { // 成员内部类

        // 内部类的方法
        public void beat() {
            System.out.println("心脏跳动：蹦蹦蹦！");
            System.out.println("我叫：" + name); // 正确写法！
        }
    }

    // 外部类的成员变量
    private String name;

    // 外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
    }

    public Body() {
    }

    public Body(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

十八、成员内部类的使用

package cn.itcast.day11.demo03;

public class Body { // 外部类

    public class Heart { // 成员内部类

        // 内部类的方法
        public void beat() {
            System.out.println("心脏跳动：蹦蹦蹦！");
            System.out.println("我叫：" + name); // 正确写法！
        }
    }

    // 外部类的成员变量
    private String name;

    // 外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
//        Heart heart = new Heart();
//        heart.beat();
        new Heart().beat();
    }

    public Body() {
    }

    public Body(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package cn.itcast.day11.demo03;

/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：
1. 成员内部类
2. 局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符 class 外部类名称 {
    修饰符 class 内部类名称 {
        // ...
    }
    // ...
}

注意：内用外，随意访问；外用内，需要内部类对象。

=====================================
如何使用成员内部类？有两种方式：
1. 间接方式：在外部类的方法中，使用内部类；然后main只是调用外部类的方法。
2. 直接方式，公式：
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

*/
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body(); // 外部类的对象
        // 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();
        System.out.println("==============================");

        // 按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}
/*
外部类的方法
心脏跳动：蹦蹦蹦！
我叫：null
==============================
心脏跳动：蹦蹦蹦！
我叫：null
*/

十九、内部类的同名变量访问

package cn.itcast.day11.demo03;

// 如果出现了重名现象，那么格式是：外部类名称.this.外部成员变量名
public class Quter {

    int num = 10; // 外部类的成员变量

    public class Inner /*extends Quter*/{
        int num = 20; // 内部类的成员变量

        public void methodInner() {
            int num = 30; // 内部类方法的局部变量
            System.out.println(num); // 局部变量，就近原则
            System.out.println(this.num); // 内部类的成员变量
            System.out.println(Quter.this.num); // 外部类的成员变量
        }
    }
}


package cn.itcast.day11.demo03;

public class Demo02InnerClass {
    public static void main(String[] args) {
        // 外部类名称. 内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Quter.Inner obj = new Quter().new Inner();
        obj.methodInner();
    }
}
/*
30
20
10
*/

二十、局部内部类定义

package cn.itcast.day11.demo04;
/*
如果一个类是定义在一个方法的内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：
修饰符 class 外部类名称 {
    修饰符 返回值类型 外部类方法名称(参数列表) {
        class 局部内部类名称 {
            // ...
        }
    }
}
小结一下类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1. 外部类：public / (default)
2. 成员内部类：public > protected > (default) > private
3. 局部内部类：什么都不能写
*/
public class Quter {

    public void methodOuter() {
        class Inner {
            int num = 10;
            public void methodInner() {
                System.out.println(num); // 10
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}


package cn.itcast.day11.demo04;

public class DemoMain {
    public static void main(String[] args) {
        Quter obj = new Quter();
        obj.methodOuter();
    }
}
// 10

二十一、局部内部类的final问题

package cn.itcast.day11.demo04;

/*
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。

备注：从Java 8+开始，只有局部变量事实不变，那么final关键字可以省略。

原因：
1. new出来的对象在堆内存中。
2. 局部变量是跟着方法走的，在栈内存当中。
3. 方法运行结束后，立刻出栈，局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
*/
public class MyQuter {
    public void methodOuter() {
        int num = 10; // 所在方法的局部变量
        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

二十二、匿名内部类

package cn.itcast.day11.demo05;

public interface MyInterface {
    void method(); // 省略了public abstract
}


package cn.itcast.day11.demo05;

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method() {
        System.out.println("实现类覆盖重写了方法！");
    }
}


package cn.itcast.day11.demo05;

/*
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};
*/
public class DemoMain {

    public static void main(String[] args) {
//        MyInterfaceImpl impl = new MyInterfaceImpl();
//        impl.method();

//        MyInterface some = new MyInterface(); // 错误写法！

        // 使用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！");
            }
        };
        obj.method();
    }
}
/*
匿名内部类实现了方法！
*/

二十三、匿名内部类的注意事项

package cn.itcast.day11.demo05;

public interface MyInterface {
    void method1(); // 抽象方法，省略了public abstract
    void method2();
}


package cn.itcast.day11.demo05;

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法！111");
    }

    @Override
    public void method2() {
        System.out.println("实现类覆盖重写了方法！222");
    }
}


package cn.itcast.day11.demo05;

/*
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};

对格式“new 接口名称() {...}”进行解析：
1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {...}这才是匿名内部类的内容

另外还有注意几个问题：
1. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调；匿名内部类和匿名对象不是一回事！
*/
public class DemoMain {

    public static void main(String[] args) {
//        MyInterfaceImpl impl = new MyInterfaceImpl();
//        impl.method();

//        MyInterface some = new MyInterface(); // 错误写法！

        // 使用匿名内部类,但不是匿名对象，对象名称就叫objA
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-A");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-A");
            }
        };
        objA.method1();
        objA.method2();
        System.out.println("===============================");

        // 使用了匿名内部类，而且省略了对象名称，也是匿名对象。
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method1();

        // 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象。
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method2();

    }
}
/*
匿名内部类实现了方法！111-A
匿名内部类实现了方法！222-A
===============================
匿名内部类实现了方法！111-B
匿名内部类实现了方法！222-B
*/

二十四、类作为成员变量类型

package cn.itcast.day11.demo06;


public class Weapon {
    public Weapon() {
    }

    public Weapon(String code) { // 武器的代号
        this.code = code;
    }

    private String code; // 武器的代号


    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}


package cn.itcast.day11.demo06;

// 游戏当中的英雄角色类
public class Hero {

    private String name; // 英雄的名字
    private int age; // 英雄的年龄
    private Weapon weapon; // 英雄的武器

    public Hero() {
    }

    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }

    public void attack() {
        System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方");
    }

    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 Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}


package cn.itcast.day11.demo06;

public class DemoMain {

    public static void main(String[] args) {
        // 创建一个英雄角色
        Hero hero = new Hero();
        // 为英雄起一个名字，并且设置年龄
        hero.setName("盖伦");
        hero.setAge(20);

        // 创建一个武器对象
        Weapon weapon = new Weapon("AK-47");
        // 为英雄配备武器
        hero.setWeapon(weapon);

        //
        hero.attack();

    }
}
/*
年龄为20的盖伦用AK-47攻击敌方
*/
Only hand ripe
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java学习day01-day15学习资料
04-05
这份资料包括了day01至day15的学习内容，主要围绕Java编程的核心概念展开。以下是对每个子文件名中涉及知识点的详细解释： 1. **day02**: 这部分可能涉及Java的基础语法，如变量、数据类型、运算符、流程控制语句...
day3 java 学习笔记
01-13
day3 java 笔记
Java自学-接口与继承 多态
我的博客
04-03 246
Java的多态 操作符的多态 +可以作为算数运算，也可以作为字符串连接 类的多态 父类引用指向子类对象 示例 1 : 操作符的多态 同一个操作符在不同情境下，具备不同的作用 如果+号两侧都是整型，那么+代表 数字相加 如果+号两侧，任意一个是字符串，那么+代表字符串连接 package charactor; public class Hero { public String nam...
Java第七章总结：继承、多态类与接口
nmy15570188135的博客
04-04 903
在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中所有的类都直接或间接继承了java.lang.Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称。定义为final的类不能被继承。将方法定义为final类型，可以防止子类修改父类的定义与现实方式，同时定义为final的方法的执行效果要高于非final方法。
头歌课堂实验 Java继承和多态之接口
weixin_49238668的博客
11-20 485
【代码】头歌课堂实验 Java继承和多态之接口。
练习-Java继承和多态之接口(19)
weixin_46075438的博客
02-13 5045
任务描述 本关任务： 编写一个学校接待方面的程序，招待不同身份的人的食宿问题。 /** * 编写一个学校接待方面的程序，招待不同身份的人的食宿问题 */ // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码 /********** Begin **********/ // 定义一个接口类 Person interface Person{ // 定义 eat()，实现输出吃饭的功能，无返回值 public abstract void eat(); //
Java中的继承与接口
qq_40167417的博客
09-03 2893
...
java学习day06
01-20
面向对象 public class Demo01PrintArray { public static void main(String[] args) { int[] array = {10, 20, 30, 40, 50}; // 使用面向过程 System.out.print([);//去掉ln,不换行 for (int i = 0;...
Java学习之旅Day01.md
11-08
Java学习之旅Day01.md
Java入门基础学习资料day11
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
JAVA接口继承接口
weixin_43586713的博客
04-11 6587
JAVA里面接口可以继承接口吗？ 答案是可以的。但是继承的话不是使用implements关键字，而是使用extends关键字。 下面这么写代码是会报错的： //这个代码肯定是会报错的，因为子接口继承父接口应该使用extends interface Animal{ // 写一个抽象方法 void test(); } interface Cat implements Animal{ } 应该按照下面这么写： interface Animal{ // 写一个抽象方法 void test(); } i
Java中类与接口的继承与实现细节
lx5210521的博客
03-27 1700
3、一个类可以同时继承一个类并实现一个接口，如。1、Java中不允许一个类继承多个类，但可以。2、一个接口可以同时继承多个接口，如。4、一个类可以同时实现多个接口，如。
类的继承与接口
qq_74688865的博客
03-28 951
Java中类的实现多态的两个方法的具体讲述。
Java继承，接口，多态
最新发布
2301_80484340的博客
05-02 326
Java继承，接口，多态
java 接口教程
m0_63538059的博客
11-29 2015
java 接口教学
Java 接口、继承与多态
仰望星空
09-10 378
                                                     第一章 继承           1.1 概念 1.1.1 继承的范围        在java中，子类可以继承父类的所有的方法和属性变量，private也能被继承但是不能被访问，可以通过public在父类中调用，子类继承父类的一切东西.          <Thinking i...
java接口的继承问题
u010921701的博客
10-16 6513
序 在看API文档时，突然发现一个接口可以是其他接口的子接口，这说明接口之间会存在继承的关系。查找了相关的资料，做一个总结。 是继承还是实现 首先要搞清楚接口之间的关系使用的关键字是extends还是implement。网友有如下回答： 一个类只能extends一个父类，但可以implements多个接口。java通过使用接口的概念来取代C++中多继承。与此同时，一个接口则可以同时
Java 接口的继承
风中的劲草
05-29 3434
我们先来回顾下接口的相关知识接口是规范，用interface关键字修饰接口，接口是是一组抽象方法定义和常量的集合，接口间的继承是多继承关系。接口的定义public 接口名{/* 零个到多个的常量定义 零个到多个的抽象方法的定义 */ }实现接口修饰符 class 类名 extends 父类名 implements 接口1，接口2，...{ // 如果继承的类是抽象类，必须实现父类的抽象方法 // 实
Java接口的继承与利用接口实现类的多重继承
kaszxc的博客
05-23 5094
接口的继承 接口也有继承性，在定义接口时可以用关键字 extends 表明本接口是某一个接口的子接口。 一个子接口可以继承多个父接口。 子接口将继承父接口中的常量、抽象方法、默认方法，不能继承静态方法。 接口的实现类不能继承接口的静态方法。 示例： package ch08; interface Face1{ final double PI=3.14; abstract double area(); } interface Face2{ abstract void
Java开发零基础篇：Day02 变量和运算符.pdf
11-03
"Java开发零基础篇Day02 变量和运算符.pdf" 在学习Java编程时，了解变量和运算符是非常基础且重要的概念。在Day02的学习中，我们首先通过一个房屋租赁合同的案例引入了变量的概念。在合同中，用"甲方"和"乙方"代替...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值