代码块，static，外内部类，箭头函数

JAVA（代码块，static，外内部类，箭头函数）

一，类的结构

//类的内部结构
    //属性，方法，构造器，代码块，内部类

代码块：

又叫初始化块，属于类的一个成员，它将逻辑语句封装在方法体里，通过{}包裹

无参数，无返回值，只有方法体

class C{
    {
        //方法体
    }
}

静态代码块：一个类被加载时会被调用一次，做一次初始化的工作

class C{
    static {
        //方法体
    }
}

实例代码块：创造实例时就会被调用一次

class C{
    {
        //实例代码块
    }
}

调用顺序：静态块，实例块，构造器

public class Test1 {
    public  Test1(){
        System.out.println("构造器");
    }
    static {
        System.out.println("静态块");
    }
    {
        System.out.println("实例块");
    }

    public static void main(String[] args) {
        Test1 t=new Test1();
    }
}

当有继承关系时，父类静态块，子类静态块，父类实例块，父类构造器，子类实例块，子类实例块

父优于子，静态优于

public class Test2 extends Test1{
    public  Test2(){
        System.out.println("构造器");
    }
    static {
        System.out.println("静态块");
    }
    {
        System.out.println("实例块");
    }

    public static void main(String[] args) {
        new Test2();
    }
}

二，static

可以修饰属性，方法，代码块
修饰属性，类名.属性名
static修饰的结构，不属于任何以一个对象
public static void show(){},静态方法

static内存解析：

1.静态的变量或静态方法，存在于方法区，静态的结构不会被垃圾回收

2.不属于某一个实例对象，只存在于方法区，调用静态结构，直接用类名.

实例方法和静态方法互相调用

1.静态方法中不可以直接调用实例方法

想用，必须对象.方法名

2.实例方法可以直接调用静态方法

静态结构的加载，随着类的加载而加载

非静态结构的方法，对着对象的创建而创建

java中调用实例方法，必须有主体

接口常量默认: public static final

静态方法没有重写的概念

this和super都不能用在静态结构中:静态结构属于类，静态结构优先于对象存在

this和super有对象才能出现，必须有实例

三，外部类：

一个public声明的类，必须和.java的文件名相同

class Carche{
     Integer tpai;
     String ch1;
}

public class Test4 {
    public static void main(String[] args) {
        Carche [] c1=new Carche[10];


    }
}

四，内部类：

可以用static修饰内部类

实例内部类不能写静态代码块，可以写实例代码块

静态内部类可以写静态代码块

实例化方式：

//实例内部类对象

外部类.内部类对象=new 外部类().new 内部类();

//静态内部类对象

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


public class Test4 {
    public static void main(String[] args) {
        
    }
    public class Carche{
     Integer tpai;
     String ch1;
    }

}

public class Test5 {
    private Integer aa = 0;
    static int nn = 2;
    final int C = 4;
    static  final int D = 5;
    public static void main(String[] args) {
        int bb = 1;
        Test5.A tt = new Test5.A();//静态内部类的调用
        Test5.A tt1 = new A();
        tt.ss();
        Test5.A.sss();
        tt.sss();
        Test5.B t2 = new Test5().new B();//实例内部类的调用
        t2.bb();
        t2.bbb();
    }
    static class  A{
        Test5 t = new Test5();
        public void ss(){
            System.out.println(t.C);//内部类调用外部类属性，属性只能是final修饰
            System.out.println(t.D);
            System.out.println(Test5.D);
        }
        static void sss(){}
        static {    //实例内部类能有实例代码块，也能有静态代码块

        }

        {

        }
    }

    class B{
        Test5 t = new Test5();

        public void bb(){
            System.out.println(t.C);
            System.out.println(t.D);
            System.out.println(Test5.D);
        }
        {  //实例内部类只能有实例代码块，不能有静态代码块

        }
        private void  bbb(){}

    }

}

五，设计模式：

为人们开发中抽象出可重复利用的方案

软件开发工程师之间沟通的行话

面向对象的设计原则：

开闭原则（open close principle ）

对扩展开放，对修改关闭（继承和实现接口）

对抽象约束，封装变化实现开闭原则

通过接口或抽象类为软件定义一个相对稳定的抽象层

将相同的可变因素封装在相同的具体实现中，派生一个实体体

里氏代换原则

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

依赖倒转

要面向接口编程，不要面向实现编程

每个类尽量提供接口或抽象类，或都有

变量的声明尽量是接口或是抽象类

任何类都不应该从具体类派生

使用继承时遵守里氏代换原则

接口隔离原则

使用多个隔离的接口

迪米特法则

合成复用原则

单一原则，一个类只做一件事

单一用例

/**
 * 单例模式
 * 一类只有一个实例
 *
 * 思路：别人不能new，构造器私有化，不能在类的外部通过new实例化
 * 在该类内部产生唯一的实例对象，封装成static类型
 * 定义一个静态方法返回唯一对象
 *
 * 饿汉式单例模式
 *不管以后会不会使用到该实例化对象，先创建，
 */

class  A{
    private A(){}

    private static final A a=new A();

    public static A getInstance(){
        return a;
    }

}
public class Test1 {
    public static void main(String[] args) {
        A a=A.getInstance();
        
    }
    
}

/**
 *懒汉式（延迟加载）
 在多线程环境中错误，不能保证单例的状态
 */
class L{
    //将自身实例化对象设为一个属性，没有赋值
    private static L l=new L();
    //构造器私有化
    private L(){}
    //
    public static L getInstance(){
        if(l==null){
            l=new L();
        }
        return l;
    }
}
public class Test2 {
    public static void main(String[] args) {
        L l=L.getInstance();
        L l1=L.getInstance();
        System.out.println(l==l1);//true
    }
}

/**
 * 内部类实现单例
 * 没有线程的问题
 *
 * 结合了饿汉式和懒汉式的优点
 * 不调用getInstance方法，就不会使用内部类
 * 内部类一旦被使用一次，以后一直用的是INSTANCE静态常量
 */
class N{
    private N(){}

    public static N getInstance(){
            return N1.INSTANCE;
    }
    private static class N1{
        private static  final N INSTANCE=new N();
    }
}

public class Test3 {
    public static void main(String[] args) {

    }
}

六，箭头函数

JDK8的新特性

函数式接口：接口里只有一个抽象方法，这个接口就叫函数式接口

用注解

@FunctionalInterface

posted @ 2022-07-27 16:26 一只神秘的猫阅读(60) 评论(0) 收藏举报

刷新页面返回顶部

一只神秘的猫