2022-07-27 第二小组 张鑫 学习笔记

实训十九天 块和内部类

1.学习重点

1.代码块

2.内部类

3.设计模式

4.单例模式

5.箭头函数

---

2.学习心得

今天学习了代码块和内部类等知识，对于设计模式的理解还需要继续深入研究一下，今天是学习的百日誓师大会，一百天后我将以什么样的能力走出去，我会努力的

---

3.学习内容

代码块

类的内部结构：
属性、方法、构造器、代码块、内部类

代码块：
又称为初始化块，属于类的一个成员，作用：将一些逻辑语句封装在方法体中

通过（）包裹。代码块没有方法名，没有参数，没有返回值，只有方法体
它是不需要通过对象或类进行显式的调用，它会在类加载或者创建对象时主动隐式调用

---

静态代码块
一个类被加载时会被调用一次，做一些初始化操作
实例代码块
每次创建实例，都会被调用一次，用的很少

---

当没有继承关系时：运行顺序：静态块>实例块>构造器
当有继承关系时：运行顺序：父类静-子类静-父类实-父类构-子类实-子类构

父优于子，静优于非静

---

static静态（类属性，类方法）

修饰属性，方法，代码块

用static修饰的结构，不属于任何一个对象

static内存解析
1.静态的变量或者静态的方法存在于方法区的。静态的结构不会被垃圾回收
2.不属于某一个实例对象，只存在于方法区，调用静态结构，直接用类名.的方式即可

实例方法和静态方法互相调用
1.静态方法中不可以直接调用实例方法，如果想用，必须调用对象，方法名
2.实例方法中可以直接调用静态方法。

静态的结构的加载，随着类的加载而加载
非静态的结构，随着对象的创建而加载
在Java中调用实例方法，必须要有主体 静态方法无论在哪里都是类名，方法名调用，用一个了类的静态方法之间可以省略类名

静态方法没有重写的概念

接口里的常量默认public static final
开发中基本常量的声明都是public static final

无论是this还是super，都不可以在静态结构中使用。
this.方法 super.方法
静态结构是属于类的，静态结构是优先于对象就存在的。
this和super，必须有对象才能出现。必须得有实例。

---

工具类

public static void plus(int i ,int j){

}
public static void sub(int i , int j){

}

---

内部类

在一个类内部进行其他类结构的嵌套操作。

public class Ch01 {

    static{
        System.out.println("外部类被加载...");
    }

    // 实例内部类
    public class Inner {
        {
            System.out.println("实例内部类被加载...");
        }
        public void show(){

        }
        public Inner(){

        }
        class Innerinner{

        }
        private String name;

    }
    // 静态内部类
    public static class InnerStatic {
        static {
            System.out.println("静态内部类被加载...");
        }
        public void show(){

        }

        public static void main(String[] args) {

        }
    }

    public static void main(String[] args) {
        // 这就是实例内部类的对象
        Inner inner = new Ch01().new Inner();
        // 静态内部类的对象
        InnerStatic innerStatic = new Ch01.InnerStatic();
    }
}

---

设计模式

设计模式是人们为软件开发中抽象出可重复利用的解决方案。
软件开发工程师之间沟通的“行话”。

面向对象的设计原则

1、开闭原则（Open Close Principle）

对扩展开放，对修改关闭。（继承，实现接口）
我们可以通过“抽象约束，封装变化”来实现开闭原则。
通过接口或者抽象类为软件定义一个相对稳定的抽象层。
将相同的可变因素封装在相同的具体实现类中。派生一个实体类就可以了。

2、里氏代换原则

子类继承父类时，除了添加新的方法完成新增的功能外，尽量不要重写父类的方法

3、依赖倒转原则

要面向接口编程，不要面向实现编程。
    a、每个类尽量提供接口或抽象类，或者两者兼备
    b、变量的类型声明尽量是接口或者是抽象类
    c、任何类都不应该从具体类派生
    d、使用继承时，要遵循里氏代换原则

4、接口隔离原则

使用多个隔离的接口

5、迪米特法则

6、合成复用原则

7、单一原则

一个类只做一件事

---

单例模式

一个类只有一个实例。

思路：

1、别人不能new，构造器私有化，不能在类的外部通过new去实例化。
2、在该类内部产生一个唯一的实例对象，把它封装成static类型
3、定义一个静态方法返回这个唯一的对象。

---

饿汉式单例模式

不管以后会不会使用到该实例化对象，先创建了再说，很着急的样子。
实现的办法就是直接new实例化。

public class Ch03 {

    private static final Ch03 ch03 = new Ch03();

    private Ch03(){}

    public static Ch03 getInstance(){
        return ch03;
    }
}

---

懒汉式（延迟加载）
什么时候调用getInstance方法，什么时候new
这种懒汉式在多线程环境中完全错误的，根本不能保证单例的状态。
《加锁》

public class Ch04 {

    // 将自身实例化对象设置为一个属性，现在是没有赋值的
    private static Ch04 ch04;

    // 构造器私有化
    private Ch04(){

    }

    public static Ch04 getInstance()  {
        if(ch04 == null){
            // xcxxxxx
            ch04 = new Ch04();
        }
        return ch04;
    }
}

---

内部类实现单例

也是懒汉式的一种，这种懒汉式没有线程的问题
结合了饿汉式和懒汉式的优点：
只要不调用getInstance方法，就不会使用内部类，
内部类一旦被使用一次只会被初始化一次，以后一直用的时INSTANCE静态常量了。

public class Ch05 {

    // 私有化构造器
    private Ch05(){

    }
    public static Ch05 getInstance() {
        return SingletonHolder.INSTANCE;
    }

    private static class SingletonHolder {
        private static final Ch05 INSTANCE = new Ch05();
    }
}

---

箭头函数：JDK8的新特性

函数式接口
如果一个接口只有一个抽象方法，这个接口就称为函数式接口。
可以用注解@FunctionalInterface标识。

1、有参数，有返回值。
 (i,j) -> {
     return i + j;
 }
 如果方法体只是一句返回值(i,j) -> i+j

2、有参数，无返回值
 (i,j) -> {
     // 方法体
 }
 如果方法体只有一句话(i,j) -> 方法体的一句话

3、无参数
 ()->{
     方法体
 }

public class Ch06 {

    public static void test(Inter01 inter01) {
//        System.out.println(inter01.show());
        inter01.show();
    }

    public static void main(String[] args) {
        // 多态，向上转型
        // 接口 对象 = new 实现类
//        Inter01 inter01 = new Impl01();
//        test(inter01);
//        test(new Inter01() {
//            @Override
//            public String show(int i,int j) {
//                return i + "," + j + "匿名实现类重写的show方法...";
//            }
//        });
        /*
            这个结构可以分为三部分
            第一部分，小括号包裹形参，类型不要
            第二部分，->
            第三部分，->方法体
            () ->System.out.println("重写的show方法...")
            当重写的方法体只有一句话时，可以精简到这种
            () -> "你好"
            当重写的方法只是有一句返回值时，可以精简到这种
         */
        test(() -> "你好");
    }
}