JAVA 08

类的内部结构: 方法 构造器 代码块 内部类 属性
代码块 
初始化块.属于类的一个成员,将一些逻辑语句封装在代码块中,代码块没有方法名,没有返回值等只有{}

不需要通过类或对象进行显示的调用,在类加载或者创建对象时主动的隐式调用

1,静态代码块

一个类被加载时会被调用一次,做一些初始化的操作

只会执行一次

static{

        }

类的加载(编译): 

方法能干的代码块都可以,

2,实例代码块

创建对象时才会加载,每次创建实例都会调用一次

{

}

一个类中可以有多个静态代码块

优先级

public class Ch1 {
    static {
        System.out.println("静态代码块");
    }
    {
        System.out.println("实例代码块");
    }

    public Ch1() {
        System.out.println("构造器");
    }

    public static void main(String[] args) {
        Ch1 ch1=new Ch1();
        /*
        静态代码块
    实例代码块
         构造器
         */
    }
}

父类静态块-子类静态块-父类实例块-父类构造器-子类实例块-子类构造器

静态代码块
子类静态代码块
实例代码块
构造器
子类实例代码块
子类构造器

this和super

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

---

内部类

在一个类中进行其他类结构的嵌套操作内部类是残缺不全的
实例内部类中不可写静态结构，其他的可以

public class Ch01 {

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


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

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

    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类型

饿汉式单例模式：

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

public class Ch03 {
    //创建一个永远是同一个的对象，可以加final更严谨,也可不加
    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){
            //如果在此处第一次调用时卡了。第二次调用没卡，结果一起进行了new Ch04，变成了多例。
            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();
    }
}

接口函数: 只能有一个抽象类

@FunctionalInterface
public class Inter01 {
}

箭头函数：JDK8的新特性

以下内容为JDK8之后的新内容
首先要明白
函数式接口：
如果一个接口只有一个抽象方法（可以有其他方法），这个接口就叫函数式接口
用注解@FunctionalInterface标注的接口就是函数式接口。

箭头函数的几种写法
1.有参数，有返回值
  （i,j） -> {return i + j;}
2.有参数，无返回值
  （i，j）-> {方法体}
3、无参数
  ()->{
      方法体
  }

public static void main(String[] args) {

        test(new In1() {
                 @Override
                 public void show() {
                     System.out.println("hhhhhhhh");
                 }
             }
             );


        test(()-> System.out.println("hhhhh"));

有返回值

  test(new In1() {
                 @Override
                 public String show(int a,int b) {

                     return "a";
                 }
             }
             );
        test(( a,b)-> "a");//或者


 test(( a,b)-> {return  "a";});

---

 这个结构可以分为三部分
            第一部分，小括号包裹形参，类型不要
            第二部分，->
            第三部分，->方法体
            () ->System.out.println("重写的show方法...")
            当重写的方法体只有一句话时，可以精简到这种
            () -> "你好"
            当重写的方法只是有一句返回值时，可以精简到这种