Day11——final、权限、内部类、引用类型

1.fina

final： 不可改变。可以用于修饰类、方法和变量。

• 类：被修饰的类，不能被继承。

• 方法：被修饰的方法，不能被重写。

• 变量：被修饰的变量，不能被重新赋值。

2.权限

• public：公共的。

• protected：受保护的

• default：默认的

• private：私有的

 

 

• 成员变量使用 private ，隐藏细节。

• 构造方法使用 public ，方便创建对象。

• 成员方法使用 public ，方便调用方法

小贴士：不加权限修饰符，其访问能力与default修饰符相同，访问private修饰的变量时，只能通过get、set方法或者构造函数初始化

单例设计模式：解决频繁调用对象的问题

饿汉式：一开始就创建

懒汉式：要用的的时候再创建

package case1;
public class SingleCase {
    /*private static SingleCase singlecase ;
    private SingleCase(){}
    public synchronized static SingleCase getInstance() {
        if (singlecase == null) {
            singlecase = new SingleCase();
        }
        return singlecase;
    }*/
    private static final SingleCase singlecase = new SingleCase();
    private SingleCase(){}

    public static SingleCase getInstance() {

        return singlecase;
    }
}

package case1;

public class Test {
    public static void main(String[] args) {
        SingleCase s1 = SingleCase.getInstance();
        SingleCase s2 = SingleCase.getInstance();
        System.out.println(s1 == s2);

    }
}

装饰设计模式：增强扩展一个方法的功能

创建装饰类1：

package case3;
/*
  装饰类_1
 */
public class DecorateUserOpration_1  implements  UserOpration{

    //包含被装饰类的引用
    private UserOpration up;

    public DecorateUserOpration_1(UserOpration up) {
        this.up = up;
    }
    @Override
    public void addUser() {
        before();
        up.addUser();
    }
    @Override
    public void editUser() {
        before();
        up.editUser();
    }
    public  void   before(){
        System.out.println("before1....");
    }
}

创建装饰类2：

package case3;

public class DecorateUserOpration_2 implements  UserOpration {

    private UserOpration op;

    public DecorateUserOpration_2(UserOpration op) {
        this.op = op;
    }

    @Override
    public void addUser() {
        before2();
        op.addUser();

    }

    @Override
    public void editUser() {
        before2();
        op.editUser();
    }

    public void before2(){
        System.out.println("before2....");
    }
}

创建接口：

package case3;

public interface UserOpration {


    //添加用户
    void  addUser();

    //编辑用户
    void editUser();

}

创建接口实现类：

package case3;

public class UserOprationImpl implements  UserOpration {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }

    @Override
    public void editUser() {
        System.out.println("编辑用户");
    }
}

创建测试类：

package case3;

public class Test {
    public static void main(String[] args) {
        //创建被装饰类的实例
        UserOpration op = new  UserOprationImpl();
        //创建装饰类一的实例
        op = new DecorateUserOpration_1(op);
        op = new DecorateUserOpration_2(op);
//        UserOpration op =  new DecorateUserOpration_2(new DecorateUserOpration_1(new  UserOprationImpl()));
        //调用装饰类一的方法
        op.addUser();
        op.editUser();

    }
}

 

 

模板模式：前后逻辑相同，抽象出中间的方法

package case5;

public abstract class Template {
    public void bussinesss() {
        System.out.println("取号");
        System.out.println("排队");
        service();
        System.out.println("对工作人员评分");
    }

    public abstract void service();
}

package case5;

public class Test extends Template {

    @Override
    public void service() {
        System.out.println("办理业务");

    }
}

 

 

3.内部类

定义：将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

格式：

class 外部类 {
    class 内部类{
    
    }
}

public class Outer1 {

    int  a = 10;
    
    class Inner1{
        int a = 20;
        public void m1(){
            System.out.println("inner...m1");
            System.out.println(a);
            //指明调用外部类的变量
            System.out.println(Outer1.this.a);
            //m2();
        }
    }
    
    
    public void m2(){
        //创建内部类的实例 - 调用内部类的实例方法
        Inner1 inner1 = new Inner1();
        inner1.m1();
    }


    public static void main(String[] args) {
        //外部类调用:先创建外部类的实例，在创建内部类的实例
        Inner1 inner1 = new Outer1().new Inner1();
        inner1.m1();
    }
    
    
}

访问特点

• 内部类可以直接访问外部类的成员，包括私有成员。

• 外部类要访问内部类的成员，必须要建立内部类的对象(实例)。

创建内部类对象格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

 匿名内部类： 匿名内部类必须继承一个父类或者实现一个父接口

格式 ：

new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
    // 执行语句
    }
};