Java面向对象2-6

代码块

代码块的构造顺序优先于构造器

细节

 单例设计模式

饿汉式

package demo04;

public class Hungry {
    //GirlFriend xh = new GirlFriend("小红");
    //GirlFriend xb = new GirlFriend("小明");
    GirlFriend girlFriend = GirlFriend.getInstance();
}

//有一个类，GirlFriend
//只能有一个女朋友
class GirlFriend{
    private String name;

    //私有化构造器
    private GirlFriend(String name){
        this.name = name;
    }
    //类的内部创建对象
    //为了能够在静态方法中，返回gf对象，需要将其修饰为static
    private static GirlFriend girlFriend = new GirlFriend("小红红");
    //提供公共的static方法，返回对象
    //加static可以不同new直接调用
    public static GirlFriend getInstance(){
        return girlFriend;
    }

}

懒汉式

package demo04;

public class Lazy {
}
class Cat{
    /*
    步骤
    1、仍然构造器私有化
    2、定义一个static静态属性对象
    3、提供一个public的static方法，可以返回一个cat对象
     */
    private String name;
    private static Cat cat;
    private Cat(String name){
        this.name=name;
    }
    public static Cat getInstance() {
        if (cat == null) {
            cat = new Cat("小可爱");
        }
        return cat;
    }
}

内部类

局部内部类

package demo04;

import Demo03.Outer;

public class LocalInnerClass {
    public static void main(String[] args){
       Outer02 outer02 =  new Outer02();
       outer02.m1();
    }
}

class Outer02{
    private int n1=100;
    private void m2(){
        System.out.println("Outer02 m2()");
    }
    public void m1(){//方法
        //1.局部内部类是定义在外部类的局部位置，通常在方法
        //3.不能添加访问修饰符，但是可以用final修饰
        //4.作用域:仅仅在定义它的方法或代码块中
        class Inner02{//局部内部类(本质仍然是一个类)
            //2.可以直接访问外部类的所有成员，包含私有的
            public void f1(){
                //5.局部内部类可以直接访问外部类的成员
                System.out.println("n1="+n1);
                m2();
            }
        }
        //6.外部类在方法中，可以创建Inner02对象，然后调用方法就可以
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

匿名内部类

使用细节

实践

package demo04;

public class AnonymousExer {
    public static void main(String[] args) {
        //当做实参直接传递，简洁高效
        f1(new IL(){
            @Override
            public void show() {
                System.out.println("这是一副名画");
            }
        });
        //传统方式 类->实现方法->new对象调用(硬编码)
        f1(new Picture());


        CellPhone cellPhone = new CellPhone();
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床");
            }
        });
    }


    //静态方法,形参是接口类型
    public static void f1(IL il){
         il.show();
    }
}

//接口
interface IL{
    void show();
}
//类->实现IL 修改容易影响到所有的实例
class Picture implements IL{
    @Override
    public void show() {
        System.out.println("重写类");
    }
}
interface Bell{
    void ring();
}
class CellPhone{
    public void alarmClock(Bell bell){
        bell.ring();
    }
}

成员内部类

package demo04;

public class MemberInner {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        
    }
}
class Outer08{//外部类
    private int n1 = 10;
    public String name = "张三";
    //1.注意成员内部类是定义在外部类的成员位置上
    //2.可以添加任意访问修饰符
    class Inner{//成员内部类
        public double n1 = 98.0;
        public void say(){
            //1.成员内部类可以使用外部类的所有成员,包含私有的
            System.out.println("Outer的n1:"+n1+" Outer的name:"+name);
        }
    }
    //写方法
    public void t1(){
        //使用了成员内部类
        Inner inner = new Inner();
        inner.say();
        System.out.println(inner.n1);
    }
}

外部其他类使用成员内部类

package demo04;

public class MemberInner {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        //第一种方式
        // 外部其他类，使用成员内部类的三种方式 //outer08.new Inner()
        Outer08.Inner inner = new Outer08().new Inner();
        inner.say();
        //第二种方式 再外部类中编写一个方法，可以返回Inner对象
        /*
            public Inner getInner(){
                return new Inner();
            }
         */
        //第三种方式


    }
}
class Outer08{//外部类
    private int n1 = 10;
    public String name = "张三";
    //1.注意成员内部类是定义在外部类的成员位置上
    //2.可以添加任意访问修饰符
    class Inner{//成员内部类
        public double n1 = 98.0;
        public void say(){
            //1.成员内部类可以使用外部类的所有成员,包含私有的
            System.out.println("Outer的n1:"+n1+" Outer的name:"+name);
        }
    }
    //写方法
    public void t1(){
        //使用了成员内部类
        Inner inner = new Inner();
        inner.say();
        System.out.println(inner.n1);
    }
    public Inner getInner(){
        return new Inner();
    }
}

静态内部类