Java学习笔记四（内部类、设计模式）

一、内部类

1、内部类的优点：

1. 当有多个类交叉调用，代码可以简化。因为内部类中可调用到外部类中的属性和方法
2. 内部类可和外部类相互访问到私有属性和方法
3. 类中的很多属性，本身是类的结构.通过内部类，便于描述.

2、开发时如何使用内部类

1. 成员内部类:
   内部类中，不准有任何static 变量或static方法.
   希望内部类类似于一个实例变量.每new一份，都会有新的属性值.
2. 静态内部类:
   如果希望内部类中有static变量或static方法，此内部类要定义为static
3. 静态内部类和成员内部类:
   3.1 此静态内部类，不须实例化.直接可通过外部类.调用
   3.2 静态内部类内部可含有static和非static属性 方法.
   3.3 静态内部类，不能再用外面的非静态属性或方法
4. 方法内部类:定义在方法里的类。
   
   因为这个类是在方法内，只在此方法内有效果，不须加public private protected 控制符.
   除了此方法能调用此类外，其它地方调用不了此类.
   适用场景：
   封装信息，别处须通过此方法得到足够的信息.
   此内部类中的方法参数：参数可以有，参数就默认为final
5. 匿名内部类:
   就是一个没有名字的方法内部类.要和方法结合使用.
   大致结构是参考方法内部类，只是没有类名，代码块还在.
   5.1 匿名内部类须先继承一个抽象类或实现一个接口
   5.2 因为没有类名，所以没有构造器.
   适合场景:懒汉式实现接口或继承抽象类.

二、设计模式

1、单例模式

单例模式:为了解决同一对象要创建很多次的问题。
因为同一个对象只创建一次，为了节约内存空间.
比如很多用户浏览同一商品，当点击同一商品的信息时，其实创建相同的对象.

public class OneDemo {
    public static void main(String[] args) {
    	//普通实现
        One one1 = new One();
        One one2 = new One();
        System.out.println(one1 == one2);
        System.out.println("------------");
        //单例模式
        One one3 = One.getOne();
        One one4 = One.getOne();
        System.out.println(one3 == one4);
        one3.buy();
    }
}

class One{
    int id = 1;
    String name = "sun";
    public void buy(){
        System.out.println("此商品在出售");
    }
    //使用单例模式
    public static One one;
    public static One getOne(){
        if (one == null){
            one = new One();
        }
        return one;
    }
}

2、工厂模式

工厂:按照传入的参数，出相应的对象
有一个工厂类或方法，专门负责按照参数，生成相应的对象。
把整个创建对象的过程，封装好。

好处:
安全系数高，并代码和业务可分离。、

代码设计:
1 因为要通过不同参数，得到不同的对象。
Host h1=Get(0)
Sch h2=Get(1)

Ho h1=Get(0)
Ho h2=Get(1)
多态.
以人–学生
老师

public class FactDemo {
    public static void main(String[] args) {
        FactDemo factDemo = new FactDemo();
        Aper stu = factDemo.getAper(0);
        stu.eat();
        Aper tea = factDemo.getAper(1);
        tea.eat();
    }
    public Aper getAper(int i){
        if (i == 0){
            return new Stu();
        }else if(i == 1){
            return new Tea();
        }else {
            return null;
        }
    }
}

interface Aper {
    abstract void eat();

    abstract void work();
}

class Stu implements Aper {

    @Override
    public void eat() {
        System.out.println("学生在学校吃饭");
    }

    @Override
    public void work() {
        System.out.println("学生主要事宜是学习");
    }
}

class Tea implements Aper{

    @Override
    public void eat() {
        System.out.println("老师在学校吃饭");
    }

    @Override
    public void work() {
        System.out.println("老师教书");
    }
}

3、代理模式

代理模式:通过第三方(代理方)，去创建所须要的对象。
支付平台:
一般用户买家，要付款
代理方: 买家先把款付给代理方，中间平台.
商家:收款.
代理模式的好处:
2.1 安全系数
2.2 甲方有时不能调用或联系上乙方

public class PriDemo {
    public static void main(String[] args) {
        FindGirl a = new Co(1);
        a.sing();
        a.coding();
    }
}

interface FindGirl{
    abstract void sing();
    abstract void coding();
}

class XiaoF implements FindGirl{

    @Override
    public void sing() {
        System.out.println("小芳会唱歌");
    }

    @Override
    public void coding() {
        System.out.println("小芳会敲代码");
    }
}

class XiaoL implements FindGirl{

    @Override
    public void sing() {
        System.out.println("小丽会唱歌");
    }

    @Override
    public void coding() {
        System.out.println("小丽会敲代码");
    }
}

class Co implements FindGirl{
    FindGirl gr;

    public Co(int i) {
        if (i == 1){
            gr = new XiaoL();
        }else if (i == 2){
            gr = new XiaoF();
        }
    }

    @Override
    public void sing() {
        gr.sing();
    }

    @Override
    public void coding() {
        gr.coding();
    }
}

三、感谢阅读

这些是老师上课写的笔记，因为很多东西都是口述讲解，笔记不全面，没有时间整理，但是代码是全的，笔记目的用于自己复习使用，各位看官能看就看，看不懂就没办法咯。有其他系列的是整理的完整版的，大家可以去看看。