自学Java第12Day

全聚德一级码师

已于 2024-07-21 23:04:37 修改

阅读量659

点赞数 12

文章标签： java 开发语言

于 2024-07-20 20:35:39 首次发布

本文链接：https://blog.csdn.net/Directionboy/article/details/140573557

版权

学习目标：面向对象进阶

学习内容：内部类

学习时间：

下午 3 点-下午 6 点

学习产出：

内部类

类的五大成员

属性、方法、构造方法、代码块、内部类

什么是内部类？

在一个类里面，在定义一个类。

举例：在A类的内部定义B类，B类就被称为内部类。

public class Outer{
    public class Inner{

    }
}

需求：写一个Javabean类描述汽车。

属性：汽车的品牌，车龄，颜色，发动机的品牌，使用年限。

public class Car {
    String carName;
    int carAge;
    String carColor;
    class Engine{
        String engineName;
        int engineAge;
    }
}

内部类表示的事物是外部类的一部分

内部类单独出现没有任何意义

内部类的访问特点

内部类可以直接诉问外部类的成员,包括私有

public class Car {
    static String carName;
    int carAge;
    String carColor;
    class Engine{
        String engineName;
        int engineAge;
        public void show(){
            System.out.println(engineName);
            System.out.println(carName);
        }
    }
}

外部类要访问内部类的成员,必须创建对象

public class Car {
    static String carName;
    int carAge;
    String carColor;
    public void show(){
        Engine e=new Engine();
        e.engineName="手摇";
        System.out.println(e.engineName);
        System.out.println(carName);
    }
    class Engine{
        String engineName;
        int engineAge;
    }
}

public class Test {
    public static void main(String[] args) {
        Car c=new Car();
        Car.carName ="宾利";
        c.carAge=1;
        c.carColor="蓝色";
        c.show();
    }
}

运行结果：

手摇
宾利

什么时候用到内部类？

B类表示的事物是A类的一部分，且B单独存在没有意义。

比如:汽车的发动机、ArrayList的迭代器、人的心脏等等。

静态内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。

创建静态内部类对象的格式：

外部类名.内部类名对象名=new 外部类名.内部类名();

调用非静态方法的格式：

先创建对象，用创建对象调用。

调用静态方法的格式：

外部类.内部类名.方法名();

public class Outer {
    static class Inner{
        public void show1(){
            System.out.println("非静态的方法被调用了");
        }
        public static void show2(){
            System.out.println("静态的方法被调用了");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner oi=new Outer.Inner();
        oi.show1();
        Outer.Inner.show2();
    }
}

运行结果：

非静态的方法被调用了
静态的方法被调用了

局部内部类

将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。

外界是无法直接使用，需要在方法内部创建对象并使用。

该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

public class Outer {
    int b=10;
    public void show(){
        int a=10;
        class Inner{
            String name;
            int age;
            public void method1(){
                System.out.println(a);
                System.out.println(b);
                System.out.println("局部内部类中的method1方法");
            }
            public static void method2(){
                System.out.println("局部内部类中的method2静态方法");
            }
        }
        Inner i=new Inner();
        System.out.println(i.name);
        System.out.println(i.age);
        i.method1();
        Inner.method2();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.show();
    }
}

运行结果：

null
0
10
10
局部内部类中的method1方法
局部内部类中的method2静态方法

匿名内部类

匿名内部类本质上就是隐藏了名字的内部类。可以写在成员位置，也可以写在局部位置。

格式：

new 类名或者接口名（）{

重写方法；

}；

public interface Swim {
    public abstract void swim();
}

public class Test {
    public static void main(String[] args) {
        new Swim(){

            @Override
            public void swim() {
                System.out.println("重写了方法");
            }
        };
    }
}

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

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

public class Test {
    public static void main(String[] args) {
        method(
                new Animal() {
                    @Override
                    public void eat() {
                        System.out.println("狗吃骨头");
                    }
                }
        );
    }
    public static void method(Animal a){
        a.eat();
    }
}

运行结果：

狗吃骨头

public class Test {
    public static void main(String[] args) {
        //整体我们可以理解为Swim接口的实现类对象
        //接口多态
        Swim s=new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了游泳类");
            }
        };
        s.swim();


        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了游泳类");
            }
        }.swim();
    }
}