Java基础学习——内部类、工厂方法的设计模式

1、工厂方法的设计模式

 

public class Test_1 {
    public static void main(String args[]){
        //工厂方法的设计模式
        IWorkFactory i = new StudentWorkFactory();
        i.getWork().doWork();
        IWorkFactory i1 = new TeacherWorkFactory();
        i1.getWork().doWork();
    }
}
/*
工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，
FactoryMethod使一个类的实例化延迟到其子类。
适用性：1、当一个类不知道它所必须创建的对象的类的时候；
       2、当一个类希望由它的子类来指定它所创建的对象的时候；
       3、当类将创建对象的职责委托给多个帮助子类中的某一个，
       并且希望将哪一个帮助子类是代理者这以信息局部化的时候。
 */
interface IWorkFactory{
    Work getWork();
}
class StudentWorkFactory implements IWorkFactory{
    @Override
    public Work getWork() {
        return new StudentWork();
    }
}
class TeacherWorkFactory implements IWorkFactory{
    @Override
    public Work getWork() {
        return new TeacherWork();
    }
}
interface Work{
    void doWork();
}
class StudentWork implements Work{
    @Override
    public void doWork() {
        System.out.println("Students do homework");
    }
}
class TeacherWork implements Work{
    @Override
    public void doWork() {
        System.out.println("Teacher work");
    }
}

2、内部类

public class Test_1 {
    public static void main(String args[]){
        //创建静态内部类的对象，可以直接通过外部类调用静态内部类的构造器
        Person.Dog d = new Person.Dog();
        //创建非静态的内部类的对象，必须先创建外部类的对象，通过外部类的对象调用内部类的构造器
        Person p = new Person();
        Person.Bird b = p.new Bird();
    }
}
/*
类的第五个成员：内部类
成员内部类（分静态/非静态内部类）：声明在类内部且方法外的；
（1）是外部类的一个成员：可以有修饰符；可以用static、final、abstract来修饰
（2）还可以在其内部定义属性、方法、构造器。
局部内部类：声明在类的方法里的。

学习要求：如何创建成员内部类
         如何区分调用外部类、内部类（尤其是变量重名时）
         局部内部类的使用
 */
class Person{
    String name = "June";
    int age;
    //成员内部类（非静态）
    class Bird{
        String name = "Bird";
        int id;
        public Bird(){

        }
        public void setName(String name){
            this.name = name;
            System.out.println(name);//b.setName(name),值为name
            System.out.println(this.name);//Bird 哪个对象调用此方法，this指向的就是对象中的name的值。
        }
        public void info(){

        }
    }
    //成员内部类（静态内部类）
    static class Dog{

    }

    public void show(){

    }
    public void method1(){
        //局部内部类
        //如下的使用方式比较少
        class InnerClass{

        }
    }
    //常常使用一个方法，使其返回值为某个类或接口的对象，而这个类或接口在方法内部创建。
    //使用方式一
    public Comparable getComparable(){
        //1、创建一个实现Comparable接口的类
        class MyComoarable implements Comparable{
            @Override
            public int compareTo(java.lang.Object o) {
                return 0;
            }
        }
        //2、返回一个实现类的对象
        return new MyComoarable();
    }
    //使用方式二
    public Comparable getComparable1(){
        //返回一个实现Comparable接口的匿名内部类的对象
        return new Comparable() {
            @Override
            public int compareTo(java.lang.Object o) {
                return 0;
            }
        };
    }
}