高级应用：内部类的设计模式与内部类与外部类之间的交互

1.内部类与外部类之间的交互

内部类与外部类之间可以相互访问对方的私有成员，这为程序设计提供了更大的灵活性和可扩展性

public class Outer {
    private int outerVar;

    public Outer(int outerVar) {
        this.outerVar = outerVar;
    }

    public void outerMethod() {
        System.out.println("Outer method");
    }

    public class Inner {
        private int innerVar;

        public Inner(int innerVar) {
            this.innerVar = innerVar;
        }

        public void innerMethod() {
            System.out.println("Inner method");
            System.out.println("Outer variable: " + outerVar); // 访问外部类的私有成员
            outerMethod(); // 调用外部类的方法
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer(10);
        Outer.Inner inner = outer.new Inner(5);
        inner.innerMethod();
    }
}

2.内部类的设计模式

内部类在设计模式中经常用于实现以下几种模式：

• 迭代器模式：内部类可以实现一个迭代器，遍历外部类的集合元素。
• 工厂模式：内部类可以实现一个工厂，用于创建外部类的实例。
• 观察者模式：内部类可以作为观察者，监听外部类的状态变化。
• 单例模式：通过私有构造方法和内部类实现线程安全的单例模式。

// 迭代器模式
public class MyCollection {
    private List<String> list;

    public MyCollection() {
        list = new ArrayList<>();
    }

    public void add(String element) {
        list.add(element);
    }

    public Iterator<String> getIterator() {
        return new MyIterator();
    }

    private class MyIterator implements Iterator<String> {
        private int index;

        @Override
        public boolean hasNext() {
            return index < list.size();
        }

        @Override
        public String next() {
            return list.get(index++);
        }
    }
}

// 工厂模式
public class AnimalFactory {
    public Animal createAnimal(String type) {
        if ("dog".equalsIgnoreCase(type)) {
            return new Dog();
        } else if ("cat".equalsIgnoreCase(type)) {
            return new Cat();
        } else {
            throw new IllegalArgumentException("Invalid animal type: " + type);
        }
    }

    private class Dog implements Animal {
        @Override
        public void makeSound() {
            System.out.println("Dog barks");
        }
    }

    private class Cat implements Animal {
        @Override
        public void makeSound() {
            System.out.println("Cat meows");
        }
    }
}

// 观察者模式
public interface Observer {
    void update(String message);
}

public class Subject {
    private List<Observer> observers;

    public Subject() {
        observers = new ArrayList<>();
    }

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// 单例模式
public class Singleton {
    private Singleton() {
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }

    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
}

总结

内部类的高级应用为Java程序设计提供了更多的设计模式和交互方式，使代码更加灵活、模块化，并且更好地实现了面向对象编程的原则。通过熟练运用内部类，可以使代码更加优雅和易于维护，提高开发效率和代码质量。