华杉研发九学习日记12 javase 内部类、lambda和枚举

华杉研发九学习日记12

一，内部类

内部类就是在类中再去定义一个类，类中有类。

类体中：成员变量 成员方法 构造器 代码块 主方法

分类：

• 成员内部类

• 局部内部类

• 静态内部类

• 匿名内部类

  ​

1.1 成员内部类

类体中直接放入的属性被称为成员变量

类体中直接放入的方法被称为成员方法

类体中直接放入的类被称为成员内部类

public class Outer {		//--外部类
    int name;       //  成员变量
    public void aa(){//  成员方法
        
    }
    class Inner{    //  成员内部类
        
    }
}

注意:
1.成员内部类直接定义在外部类的类体中，可以使用public修饰

2.成员内部类中可以定义非static修饰的属性，方法，构造器，代码块

3.成员内部类中可以调用外部类中的所有的属性和方法(包含static和private修饰的属性和方法)

4.成员内部类要依赖于外部类的存在而存在，则创建对象时必须有外部对象的使用
格式:外部类名.内部类名 内部类对象 = 外部类对象名.new内部类名();

5.如果内部的属性和方法与外部类的属性和方法重名时，外部类的属性和方法在内部类中是隐藏的,我们就可以使用外部类名.this.属性和外部类名.this.方法(来调用

1.2 静态内部类

外部类体中用static修饰的内部类

注意:
1.静态内部类是定义在外部类的类体中，可以使用static修饰

2.静态内部类中可以定义所有的属性和方法（包含使用static修饰)

3.静态内部类只可以访问外部类的使用static修饰的属性和方法

4.静态内部类使用static修饰，则创建对象的格式:外部类.内部类对象名= new外部类.内部类（）;

5.静态内部类中的普通属性和方法使用对象名.局性/方法调用，静态属性和方法使用类名,属性/方法调用

1.3 局部内部类

局部内部类定义在方法中

public class AA {
    //  局部内部类
    public void aa(){
        class BB{
            
        }
    }
}

注意:
1.局部内部定义在方法体中，不能使用static和public筹修饰符修饰

2.局部内部类中的所有的属性和方法不能使用static修饰

3.局部内部类可以访问外部类中的所有的属性和方法（包含static修饰的)

4.局部内部类只能作用于其定义的方法体中，如果需要外部调用，则必须只能在方法体中使用new类创建对象，并在外部调用局部内部类所属的方法来实现调用。

1.4 匿名内部类（重点）

匿名内部类就是没有名称的类，对抽象类和接口的方法的重写。

对方法进行重写，但是没有类体，节省了空间，增强代码简易度

分类：

​ 1.对抽象类的操作

​ 2.对接口的操作

匿名内部类对抽象类的操作：

public static void main(String[] args) {
    Animal cat=new Cat();
    cat.eat();

    //  如果只是对eat方法进行重写,没有其他的属性和方法的扩展
    //  匿名内部类来实现
    
    Animal dog=new Animal() {
        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    };
}

匿名内部类对接口的操作：

public static void main(String[] args) {
    //  使用匿名内部类实现
    Cooking c1= new Cooking() {
        @Override
        public void cook() {
            System.out.println("做饭");
        }
    };
    Cooking c2= new Cooking() {

        @Override
        public void cook() {
            System.out.println("小孤鸡做饭");
        }
    };
    c1.cook();
    c2.cook();
}

二，lambda（箭头函数）

Lambda允许把函数作为一个方法的参数〔函数作为参数传递进方法中)。使用Lambda表达式可以使代码变的更加简洁紧凑。

lambda表达式只能用于简化函数式接口对应的匿名内部类

lambda表达式由3部分组成: lambda形参列表,箭头以及lambda方法体.

条件:
接口必须是函数式接口(该接口中的抽象方法只能有且仅有一个)

//  函数式接口   --该接口中有且仅有一个抽象方法
public interface Ina {
    void aa();
}

public static void main(String[] args) {
    //  创建对象
    Ina In1=new InaZi();
    In1.aa();
    //  匿名内部类
    Ina in2=new Ina() {
        @Override
        public void aa() {
            System.out.println("匿名内部类");
        }
    };
    in2.aa();
    //lambda 简写
    Ina In3=()-> {
        System.out.println("lambda表达式");
    };
    In3.aa();
}

注意：

​ 1.如果方法体只有一行，则可以省略花括号

​ 2.如果方法中有参数列表，则参数中的数据类型可以省略不写

​ 3.如果方法中的参数有且仅有一个参数，则可以省略小括号

​ 4.如果方法中有返回值，且返回值有且仅有一条语句，则可以把大括号和return一起省略

//lambda 简写
Ina In3=()-> System.out.println("lambda表达式");
In3.aa();
Inb In4=(int num)-> System.out.println(num);
In4.bb(10);
Inb In6=(num)-> System.out.println(num*5);
In6.bb(10);
Inb In5=num-> System.out.println(num*10);
In5.bb(10);
/// 对有返回值的方法
Inc Inc1=(a,b)->{
    int sum=a+b;
    return sum;
};
int sum= Inc1.sum(33,44);
System.out.println(sum);
// 简写
Inc Inc2=(a,b)->a+b;
System.out.println(Inc2.sum(1,99));

三，枚举

枚举类创建特有的对象供程序使用，规定了固定的值，以达到统一和限制

//  性别的枚举，男 女
public enum Sex {
    //  对象
    //  类似于  new MALE("男");     实现构造器
    MALE("男"),FEMALE("女");
    private String name;

    public String getName() {
        return name;
    }

    Sex(String name) {
        this.name = name;
    }
}

public static void main(String[] args) {
    //男生
    Sex man=Sex.MALE;
    //  打印枚举值
    System.out.println(man.getName());
    //  获取枚举类里面的所有的值
    Sex se[]=Sex.values();
    for(Sex s:se){
        System.out.println(s.getName());
    }
}