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  供給型接口 無參一傳回值