java基础 内部类 lambda 函数式接口

重点

接口和抽象类的区别（面试考点）

多态应用场景

深浅克隆区别

接口特点

为什么用

1. 功能扩展，不关心具体实现是谁
2. 规约/规范 必须满足才能具有某些功能，一般用于写底层类似JDK，或者自己封装小工具

是什么

• 三大引用类型之一，类 数组，接口
• 主要封装方法

特点

     全局变量 可以使用类去定义，也可以用接口定义

接口应用场景

内部类

package kgc_byme.day13.a.test;

interface A{
    void run();

}
class B implements A{

    @Override
    public void run() {
        System.out.println("aaaasasa");
    }


    public void fly() {

    }
}



public class test {
    public static void main(String[] args) {
        A a= new A() {

            @Override
            public void run() {
                System.out.println("b跑");
            }


            public void fly() {

            }
        };
        a.run();
        System.out.println("------------");
        new A(){

            @Override
            public void run() {
                System.out.println("bbbbbbbb");
            }

            public void fly() {

            }
        }.run();

        System.out.println("----------");
        ((A) () -> System.out.println("bbbbbbbb")).run();


    }
}
           

静态内部类

单例设计模式

Lambda

package kgc_byme.day13.a;

/**
 * @Description: TODO
 * @author: azzhu
 * @date:2021/5/27 11:12
 */
public class TestLambda {
    public static void main(String[] args) {
        //口诀：1.拷贝小括号，写死右箭头，给大括号，大括号里面就是我们的方法体内容
        //2.若方法体，只有一行语句，{}可以省略
        //3.有参数的话，参数类型可以省，它会自动推断；若1参，则可以省略(),多参()不能省
        //4.无参有返回值，若只有一行语句，则可以省略return，直接返回具体的值即可
        //5.有参有返回值，适用于上述口诀
       A a = () -> {
            System.out.println("aaaaa");
        };
       a.m1();

       A a1 = () -> System.out.println("aaa");

       B b =  (int num1)  -> System.out.println(num1);
       b.m1(10);

        B b1 =  (num1)  -> System.out.println(num1);
        b1.m1(20);

        B b2 =  num1  -> System.out.println(num1);
        b2.m1(20);

        B b3 = System.out::println;
        b3.m1(20);

        C c = (int num1,double num2) -> {
            System.out.println("--------");
            System.out.println(num1+num2);
        };
        c.m3(10,20);

        C c2 = (num1,num2) -> {
            System.out.println("--------");
            System.out.println(num1+num2);
        };

       D d =  () -> {
           System.out.println("aaaa");
           return 100;};
        System.out.println(d.m4());

        D d2 =  () -> 100;
        System.out.println(d2.m4());

        F f = (num1,num2) -> (int) (num1 + num2);
        System.out.println(f.m5(10,10.11));

        G g = (A aa) -> f;
        G g1 = aa -> f;
        G g2 = aa -> (num1,num2) -> (int) (num1 + num2);
        int sum = g1.m6(a1).m5(10, 20);
        int sum2 = g1.m6(() -> System.out.println("aaa")).m5(10, 20);
        System.out.println(sum);
    }
}

interface G {
    F m6(A a);
}

interface F {
    int m5(int num1,double num2);
}

interface D {
    int m4();
}

interface C {
    void m3(int num1,double num2);
}

interface B {
    void m1(int num1);
}

interface A {
    //1.无参，无返回值
    void m1();

    //2.1参，无返回值

    //3.2参以上，无返回值

    //4.无参，有返回值

    //5.有参，有返回值
}
           

IDEA内快捷键 搜索 CTRL+N

内部类

前面已经有的几个类成员：成员变量，方法（普通，构造），代码块（动态 静态）

内部类，是类的组成部分，

定义：在一个类的内部，HashMap中定义了内部类、

分类：成员内部类，局部内部类，匿名内部类：使用比较多，静态内部类

成员内部类

package kgc_byme.day15.test.test;

import kgc_byme.day09.test03.C;

import java.util.Arrays;

/**
 * @Description:
 * @author:myh
 * @date: 2021/5/31  8:35
 */
public class test {
    public static void main(String[] args) {
//        System.out.println(Arrays.toString(args));
        Circle circle =new Circle(4);
        circle.m1();
        Circle.Draw draw=circle.new Draw();
        draw.drawShape();
        Circle.Draw draw1=circle.getDrawShape();

    }


}
           

package kgc_byme.day15.test.test;

/**
 * @Description:
 * @author:myh
 * @date: 2021/5/31  8:41
 */
public class Circle {
    double  radius;

    public Circle(double radius) {
        this.radius = radius;
    }
    public void m1(){
        System.out.println("aaaa");
    }

    class Draw{
        public void drawShape(){
            System.out.println("drawshape");
        }
    }
    public Draw getDrawShape(){

        return new Draw();
    }


}
           

局部内部类

package kgc_byme.day15.test.test;

/**
 * @Description:
 * @author:myh
 * @date: 2021/5/31  8:50
 */
public class People {
}
class Man{
    public Man() {
    }


    public People getWoman(){
        class Woman extends People{
            int age=0;
        }
        return new Woman();
    }
}
           

局部内部类是定义在一个方法或者一个作用域里面的类，他和内部成员类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

匿名内部类

使用层面，没有理论，目标就是简化前面使用。

静态内部类

静态内部类实现单例设计模式，单例：单个对象

* 单例的几个要点：饿汉式，即在类加载的时候就将对象创建好，而且创建一份 static final

* 1.构造私有化,只能在类的内部去创建对象

* 2.类加载就创建对象，即 private static final HungrySingleton instance = new

HungrySingleton();

* 3.既然不能在外部创建对象了，所以就不能通过对象的方式调用方法了，

* 所以需要需要提供一个public static 修饰的方法

单例设计模式

/**
* 单例的几个要点：饿汉式，即在类加载的时候就将对象创建好，而且创建一份 static final
* 1.构造私有化,只能在类的内部去创建对象
* 2.类加载就创建对象，即 private static final HungrySingleton instance = new
HungrySingleton();
* 3.既然不能在外部创建对象了，所以就不能通过对象的方式调用方法了，
* 所以需要需要提供一个public static 修饰的方法
* @Description: TODO
* @author: azzhu
* @date:2021/5/27 10:56
*/
public class HungrySingleton {
//保证不能在外部new
private HungrySingleton(){}
//只有一份，不可更改
private static final HungrySingleton instance = new HungrySingleton();
//提供一个public的，而且只能通过类名调用的
public static HungrySingleton getInstance() {
return instance;
}
}
           

静态内部类方式

package kgc_byme.day15.test.test;

/**
 * @Description:
 * @author:myh
 * @date: 2021/5/31  9:07
 */
class Singleton {
    private static class SingletonHolder{
        private  static  final Singleton INSTANCE=new Singleton();

    }
    private  Singleton(){}

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

函数式接口

Function  功能型接口  一参一返回值 R apply(T t)

Consumer 消费型接口  一参无返回值 void accept(T t)

Supplier  供给型接口 无参一返回值