花几千上万学习Java，真没必要！（二十六）

沐风听雨_A

于 2024-07-24 20:21:17 发布

阅读量240

点赞数 13

文章标签：学习 java 开发语言

本文链接：https://blog.csdn.net/wehpd/article/details/140672353

版权

1、成员内部类：

package internalclass.com;
//在Java中，成员内部类（也称为非静态内部类）是定义在另一个类（外部类）内部的类。
//成员内部类可以访问外部类的所有成员（包括私有成员），并且每个成员内部类的实例都隐式地与其外部类的实例相关联。
//Phone的外部类中定义一个成员内部类，表示手机的不同配置或特性（例如，Camera类作为Phone的成员内部类）。
//Camera是Phone的成员内部类。Camera类的实例总是与Phone类的某个实例相关联。
//在Camera的takePhoto方法中，能够访问Phone类的私有成员brand，表示成员内部类可以访问外部类私有成员的特性。
//成员内部类的实例不能独立于其外部类的实例存在。
//通过Phone类的实例phone来创建Camera类的实例camera。
//如果直接实例化Camera（比如，Phone.Camera camera = new Phone.Camera(12);），将导致编译错误，因为Camera是一个非静态内部类，它需要外部类的一个实例来与之关联。
//成员内部类可以有自己的构造方法、字段和方法，就像任何其他类一样。
//但是，由于它与外部类紧密相关，因此可以访问外部类的所有成员（包括私有成员）。
public class Phone {  
    // 外部类的私有成员  
    private String brand;  
  
    // 外部类的构造方法  
    public Phone(String brand) {  
        this.brand = brand;  
    }  
  
    // 成员内部类 Camera  
    public class Camera {  
        // 成员内部类的成员  
        private int megapixels;  
  
        // 成员内部类的构造方法  
        public Camera(int megapixels) {  
            this.megapixels = megapixels;  
        }  
  
        // 成员内部类的方法  
        public void takePhoto() {  
            System.out.println(brand + " phone is taking a photo with " + megapixels + " megapixels camera.");  
        }  
    }  
  
    // 外部类的方法，用于创建和返回Camera实例  
    public Camera getCamera(int megapixels) {  
        return new Camera(megapixels);  
    }  
  
    public static void main(String[] args) {  
        // 创建Phone实例  
        Phone phone = new Phone("Apple");  
  
        // 通过Phone实例创建Camera实例  
        Phone.Camera camera = phone.getCamera(12);  
  
        // 调用Camera实例的方法  
        camera.takePhoto();  
    }  
}

运行结果如下：

2、局部内部类;

package internalclass.com;
//在Java中，局部内部类是定义在方法或代码块内部的类。
//与成员内部类不同，局部内部类不能包含静态成员，并且只能在其被定义的代码块或方法中访问。
//电脑类（Computer）作为外部类，并在其中一个方法中定义局部内部类。
//在一个电脑类中定义一个方法，该方法用于根据不同的配置（通过局部内部类表示）来构建并描述电脑的不同版本。
//Configuration是一个局部内部类，它被定义在describeConfiguration方法内部。
//这个局部内部类代表电脑的配置，并包含了CPU和RAM等属性。
//在describeConfiguration方法中，根据传入的configName参数创建Configuration实例，并调用它的printConfiguration方法打印配置信息。
//局部内部类Configuration的实例只能在describeConfiguration方法内部被创建和使用。
//一旦离开这个方法，Configuration的实例就不再可用，且Configuration类本身也不再可见。
//这就是局部内部类的作用域限制。
public class Computer {  
    // 外部类的成员变量  
    private String brand;  
  
    // 外部类的构造方法  
    public Computer(String brand) {  
        this.brand = brand;  
    }  
  
    // 一个包含局部内部类定义的方法  
    public void describeConfiguration(String configName) {  
        class Configuration {  
            // 局部内部类的成员变量  
            private String cpu;  
            private int ram;  
  
            // 局部内部类的构造方法  
            public Configuration(String cpu, int ram) {  
                this.cpu = cpu;  
                this.ram = ram;  
            }  
  
            // 局部内部类的方法，用于描述配置  
            public void printConfiguration() {  
                System.out.println("Configuration: " + configName);  
                System.out.println("Brand: " + brand);  
                System.out.println("CPU: " + cpu);  
                System.out.println("RAM: " + ram + " GB");  
            }  
        }  
  
        // 根据传入的configName参数创建不同的Configuration实例  
        // 基于configName创建一个固定的配置  
        // 在实际应用中，可能需要根据configName动态构建配置  
        if ("High-End".equals(configName)) {  
            Configuration highEndConfig = new Configuration("Intel Core i9", 32);  
            highEndConfig.printConfiguration();  
        } else if ("Budget".equals(configName)) {  
            Configuration budgetConfig = new Configuration("AMD Ryzen 3", 8);  
            budgetConfig.printConfiguration();  
        } else {  
            System.out.println("Unknown configuration: " + configName);  
        }  
    }  
  
    public static void main(String[] args) {  
        Computer appleComputer = new Computer("Apple");  
        appleComputer.describeConfiguration("High-End");  
  
        Computer lenovoComputer = new Computer("Lenovo");  
        lenovoComputer.describeConfiguration("Budget");  
    }  
}

运行结果如下：

3、匿名内部类：

测试代码1：

package internalclass.com;
import javax.swing.*;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
 //在Java开发中，匿名内部类常用于只需要使用一次的类实现，特别是当你想要实现某个接口或继承某个类（通常是抽象类）并立即使用其对象时。
//这种方式可以避免创建大量仅用于一次的单独类文件，从而使代码更加简洁。
//假设正在开发一个GUI应用程序，并且想要为某个按钮添加一个点击事件监听器。
//使用Swing库中的JButton和ActionListener接口实现匿名内部类的使用。
//ActionListener是一个接口，它有一个actionPerformed方法需要被实现。
//通过匿名内部类的方式实现ActionListener接口，并重写actionPerformed方法。
//当按钮被点击时，就会触发这个方法，显示一个对话框。
//使用匿名内部类的好处是，它允许直接在需要的地方实现接口或创建类的匿名子类，而无需先声明一个单独的类。
public class AnonymousInnerClassExample {  
  
    public static void main(String[] args) {  
        // 创建 JFrame 实例  
        JFrame frame = new JFrame("Anonymous Inner Class Example");  
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        frame.setSize(300, 200);  
  
        // 创建 JButton 实例  
        JButton button = new JButton("Click Me!");  
  
        // 为 JButton 添加 ActionListener，使用匿名内部类  
        button.addActionListener(new ActionListener() {  
            @Override  
            public void actionPerformed(ActionEvent e) {  
                // 当按钮被点击时，执行这里的代码  
                JOptionPane.showMessageDialog(frame, "Button was clicked!");  
            }  
        });  
  
        // 将 JButton 添加到 JFrame  
        frame.getContentPane().add(button);  
  
        // 设置 JFrame 可见  
        frame.setVisible(true);  
    }  
}

测试代码2：

package internalclass.com;
//在Java中，匿名内部类是一种没有名称的内部类，通常用于简化代码，特别是当只需要使用某个类的子类一次时。
//使用鞋子类（Shoe）作为外部类，并在其中演示匿名内部类用法。
//假设有一个Shoe类，它有一个抽象方法describe，用于描述鞋子的特性。
//然后，通过匿名内部类的方式来实现这个抽象方法。
//Shoe是一个抽象类，它有一个抽象方法describe。
//但是，没有直接继承Shoe类创建子类，而是通过在需要Shoe类实例的地方直接使用匿名内部类的方式来实现describe方法。
//这样可以为每个特定的Shoe实例提供不同的describe实现，而无需创建多个具体的子类。
//通过匿名内部类，可以使代码更加紧凑和易于理解，特别是在只需要某个类的简单实现时。
//当实现变得复杂时，考虑使用具体的子类可能是一个更好的选择，以保持代码的清晰和可维护性。
abstract class Shoe {  
    // 抽象方法，用于描述鞋子的特性  
    public abstract void describe();  
  
    // 可能有其他方法和字段...  
}  
  
public class MainTest {  
    public static void main(String[] args) {  
        // 使用匿名内部类来创建 Shoe 的一个实例  
        Shoe sneaker = new Shoe() {  
            // 实现抽象方法  
            @Override  
            public void describe() {  
                System.out.println("This is a sneaker with stylish design and comfortable fit.");  
            }  
  
            // 这里不能定义额外的抽象方法或静态成员  
            // 但可以定义其他非抽象方法和字段  
        };  
  
        // 调用 describe 方法  
        sneaker.describe();  
  
        // 再创建一个不同类型的鞋子实例，也使用匿名内部类  
        Shoe formalShoes = new Shoe() {  
            @Override  
            public void describe() {  
                System.out.println("These are formal shoes with classic styling.");  
            }  
        };  
  
        // 调用 describe 方法  
        formalShoes.describe();  
    }  
}