Day03-Java进阶-JDK8和JDK9接口新特性&代码块&内部类&Lambda表达式&(窗体、组件、事件)

1. JDK8和JDK9接口新特性

package com.itheima.minterface.jdk8;

public class InterfaceTest {
    /*
        JDK8版本接口特性:

            1. 允许定义非抽象方法, 需要加入default关键字

                    - 作用: 解决接口的升级问题
                    - 注意事项:
                                1. public可以省略, 但是default不能省略
                                2. 默认方法, 实现类是允许重写的, 但是需要去掉default关键字
                                3. 如果实现了多个接口, 多个接口中存在相同的默认方法, 实现类必须重写默认方法

            2. 允许定义静态方法

                    - 理解: 既然接口已经允许方法带有方法体了, 干脆也放开静态方法, 可以类名调用

                    - 注意事项:
                                1. public可以省略, 但是static不能省略
                                2. 接口中的静态方法, 只允许接口名进行调用, 不允许实现类通过对象调用
     */
    public static void main(String[] args) {
        AInterImpl a = new AInterImpl();
        a.method();

        //a.function();   //不允许实现类通过对象名调用
        A.function();
    }
}

interface A{
    default void method(){
        System.out.println("Inter...method");
    }

    public static void function(){
        System.out.println("A...static...function");
    }
}

interface Inter {
    void show();

    void print();

    public default void method() {
        System.out.println("Inter...method");
    }
}

class AInterImpl implements Inter, A{

    @Override
    public void method() {
        //super.method(); 找亲爹的调用, 是用extends继承父类
        Inter.super.method(); //找干爹Inter的调用
        A.super.method(); //找干爹Inter的调用

        System.out.println("AInterImpl...method");
    }

    @Override
    public void show() {
        System.out.println("AInterImpl...show");
    }

    @Override
    public void print() {
        System.out.println("AInterImpl...print");
    }
}

class BInterImpl implements Inter {

    @Override
    public void show() {
        System.out.println("BInterImpl...show");
    }

    @Override
    public void print() {
        System.out.println("BInterImpl...print");
    }
}

package com.itheima.minterface.jdk9;

public class InterfaceTest {
    /*
        JDK9接口特性 :
            接口中允许定义私有方法

            注意: 接口中的私有方法不能带有default, 只有静态方法才能调用静态成员和方法
     */
    public static void main(String[] args) {

    }
}

interface Inter{
    void show();
    void print();

    public default void start(){
        System.out.println("start方法执行");
        log();
    }

    public default void end(){
        System.out.println("end方法执行");
        log();
    }

    private static void log(){
        System.out.println("日志记录");
    }
}

2. 代码块

package com.itheima.block;

import java.net.Socket;

public class BlockTest {
    /*
        代码块: 使用 { } 括起来的代码称为代码块

        分类:
                1. 局部代码块
                        位置: 方法中的一对大括号
                        作用: 限定变量的生命周期, 提早的释放内存

                2. 构造代码块
                        位置: 类中方法外的一对大括号
                        特点: 在创建对象, 执行构造方法的时候, 就会执行构造代码块 (优先于构造方法执行)
                        作用: 将多个构造方法中, 重复的代码, 抽取到构造代码块中, 从而提升代码的复用性.

                3. 静态代码块
                        位置: 类中方法外的一对大括号, 需要加入static关键字
                        特点: 随着类的加载而执行, 因为类只加载一次, 所以也就只执行一次
                        作用: 对数据进行初始化
     */
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student(10);
    }
}

class Student{

    static String school;

    static {//随着类的加载而执行, 且只加载一次
        school = "黑马程序员";
        System.out.println("static...Student类的静态代码块");

        // Socket
    }

    {
        System.out.println("Student类的构造代码块");
        System.out.println("好好学习");
    }

    public Student(){
        System.out.println("空参构造方法...");
    }

    public Student(int num) {
        System.out.println("带参构造方法...");
    }
}

3. 内部类

3.1 内部类介绍

package com.itheima.inner;

public class InnerTest {
    /*
        内部类: 在类中定义的类

        创建对象格式: 外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();

        成员访问细节 :

                    1. 内部类中, 访问外部类成员 : 直接访问, 包括私有
                    2. 外部类中, 访问内部类成员 : 需要创建对象进行访问
     */
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        System.out.println(oi.num);
        oi.show();

        System.out.println("----------------------");

        MyOuter.MyInner mm = new MyOuter().new MyInner();
        mm.show();
    }
}

class MyOuter{

    int num = 10;

    class MyInner{
        int num = 20;

        public void show(){
            int num = 30;

            System.out.println(num);        //30
            System.out.println(this.num);   //20
            System.out.println(MyInner.this.num);           //10
        }
    }
}

class Outer {

    public void method() {
        System.out.println("method...");
        Inner i = new Inner();
        System.out.println(i.num);
    }

    class Inner {
        int num = 10;

        public void show() {
            System.out.println("show...");
            method();
        }
    }
}

3.2 内部类的分类

package com.itheima.inner;

public class StaticInnerTest {
    /*
        静态内部类 : static 修饰的成员内部类

        创建对象格式 : 外部类名.内部类名 对象名 = new 外部类名.内部类对象();

        注意事项 : 静态只能访问静态
     */
    public static void main(String[] args) {
        OuterClass.InnerClass.show();
    }
}

class OuterClass{

    int num1= 10;
    static int num2 = 20;

    static class InnerClass{

        public static void show(){
            System.out.println("show...");

            OuterClass o = new OuterClass();
            System.out.println(o.num1);
            System.out.println(num2);
        }
    }
}

3.3 匿名内部类(重点掌握)

package com.itheima.inner;

public class AnonClassTest1 {
    /*
      匿名内部类 :

          概述 : 匿名内部类本质上是一个特殊的局部内部类 (定义在方法内部)
          前提 : 需要存在一个接口或类
          格式 :
                  new 类名\接口名 () {

                  }

                  new 类名(){} : 代表继承这个类
                  new 接口名(){} : 代表实现这个接口

          结论 : 可以让代码变得更加简洁, 在定义类的时候对其进行实例化
   */
    public static void main(String[] args) {

        // 问题: 方法的形参是接口类型, 我们该传入的是什么?
        // 答案: 传入的是该接口的实现类对象
        useInter(new InterImpl());

        useInter(new Inter(){

            @Override
            public void show() {
                System.out.println("匿名内部类...show...");
            }
        });

    }

    public static void useInter(Inter i) { // Inter i = new InterImpl();
        i.show();
    }
}

interface Inter {
    void show();
}

class InterImpl implements Inter{

    @Override
    public void show() {
        System.out.println("InterImpl....show...");
    }
}

4. Lambda表达式

4.1 Lambda表达式概述

package com.itheima.lambda;

public class LambdaDemo1 {
    /*
        Lambda表达式 : JDK8开始后的一种新语法形式

            作用: 简化匿名内部类的代码写法.
            格式: () -> {}

                    () : 匿名内部类被重写方法的形参列表
                    {} : 被重写方法的方法体代码
     */
    public static void main(String[] args) {

        useInterA(new InterA() {
            @Override
            public void show() {
                System.out.println("Lambda表达式, 重写后的show方法...");
            }
        });

        System.out.println("------------------------------------");

        useInterA(() -> {
            System.out.println("匿名内部类, 重写后的show方法...");
        });
    }

    public static void useInterA(InterA a) {
        a.show();
    }
}

interface InterA {
    void show();
}

package com.itheima.lambda;

public class LambdaDemo2 {
    /*
        Lambda表达式, 只允许操作函数编程接口 : 有, 且仅有一个抽象方法的接口
     */
    public static void main(String[] args) {

        useInterB(new InterB() {
            @Override
            public void show1() {
                System.out.println("匿名内部类...show1...");
            }

            @Override
            public void show2() {
                System.out.println("匿名内部类...show2...");
            }
        });
        System.out.println("-------------------------");

        // useInterB( () -> {});
    }

    public static void useInterB(InterB b){
        b.show1();
        b.show2();
    }
}

// @FunctionalInterface
interface InterB{
    void show1();
    void show2();
}

4.2 Lambda表达式的省略规则

package com.itheima.lambda.test;

public class LambdaTest1 {
    /*
     Lambda中 () 的省略
    */
    public static void main(String[] args) {

        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类, 重写后的show方法...");
            }
        });

        System.out.println("------------------------------");

        useShowHandler(() -> System.out.println("我是匿名内部类, 重写后的show方法..."));
    }

    public static void useShowHandler(ShowHandler showHandler){

        showHandler.show();
    }
}

interface ShowHandler{
    void show();
}

package com.itheima.lambda.test;

public class LambdaTest2 {
    /*
     Lambda中参数类型的省略
 */
    public static void main(String[] args) {

        userStringHandler(new StringHandler() {
            @Override
            public void printMessage(String msg) {
                System.out.println("匿名内部类打印: "+msg);
            }
        });

        System.out.println("------------------------------");

        userStringHandler(msg -> System.out.println("匿名内部类打印: "+msg));
    }

    public static void userStringHandler(StringHandler stringHandler){
        // String
        stringHandler.printMessage("itheima");
    }
}

interface StringHandler{
    void printMessage(String msg);
}

package com.itheima.lambda.test;

import java.util.Random;

public class LambdaTest3 {
    /*
         Lambda中return的省略
     */
    public static void main(String[] args) {
        useRandomNumHandler(new RandomNumHandler() {
            @Override
            public int getNumber() {
//                Random r = new Random();
//                int num = r.nextInt(100) + 1;
//                return num;

                return new Random().nextInt(100) + 1;
            }
        });

        System.out.println("--------------------------");

        useRandomNumHandler(() -> new Random().nextInt(100) + 1);
    }

    public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
        int result = randomNumHandler.getNumber();
        System.out.println(result);
    }
}

interface RandomNumHandler {
    int getNumber();
}

package com.itheima.lambda.test;

public class LambdaTest4 {
    /*
        计算器
     */
    public static void main(String[] args) {

        useCalculator(new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a + b;
            }
        });

        System.out.println("------------------------");

        useCalculator((a, b) -> a - b);

    }

    public static void useCalculator(Calculator calculator) {
        int result = calculator.calc(10, 20);
        System.out.println(result);
    }
}

interface Calculator {
    int calc(int a, int b);
}

4.3 Lambda表达式和匿名内部类的区别

5. 窗体、组件、事件

5.1 窗体搭建

package com.itheima.frame;

import javax.swing.*;

public class JFrameTest {
    public static void main(String[] args) {
        // 创建窗体对象
        JFrame frame = new JFrame();

        // 设置窗体大小, 其中的500和800指的是像素
        frame.setSize(500, 800);

        // 修改窗体的关闭模式
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 设置窗体的标题
        frame.setTitle("这是大哥的第一个窗体!");

        // 设置窗体可见 (这一步一定要放在最后, 避免其中有些图片或按钮没显示)
        frame.setVisible(true);
    }
}

5.2 窗体添加按钮

package com.button;

import javax.swing.*;

public class JButtonTest {
    /*
        案例演示: 窗体中添加按钮组件

        -------------------------------------------
        JButton构造方法 :

                1. public JButton() : 创建一个空白的按钮
                2. public JButton(String text) : 创建一个带文本的按钮
        ---------------------------------------------

        注意: 如果取消了窗体的默认布局, 就需要手动指定组件的摆放位置了
     */
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setSize(500, 500);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        //取消窗体的默认布局
        frame.setLayout(null);

        // 1. 创建按钮对象
        JButton btn = new JButton("点我呀");
        btn.setBounds(50, 50, 100, 50);
        // 2. 将按钮添加到窗体的 [面板对象] 中
        frame.getContentPane().add(btn);

        frame.setVisible(true);
    }
}

5.3 JLabel 组件展示文本和图片

5.4 事件监听

6. 适配器设计模式

package com.itheima.adapter;

import javax.swing.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class AdapterTest1 {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setSize(500, 500);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        frame.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                System.out.println("键盘被按下了...");
            }
        });

        frame.setVisible(true);
    }
}

package com.itheima.adapter;

public class AdapterTest2 {
    /*
        适配器设计模式: 解决接口和接口实现类之间的矛盾问题
     */
    public static void main(String[] args) {

    }
}

interface 和尚 {
    void 打坐();

    void 念经();

    void 撞钟();

    void 习武();
}

abstract class 和尚Adapter implements 和尚 {

    @Override
    public void 打坐() {

    }

    @Override
    public void 念经() {

    }

    @Override
    public void 撞钟() {

    }

    @Override
    public void 习武() {

    }
}

class 鲁智深 extends 和尚Adapter{
    @Override
    public void 习武() {
        System.out.println("拳打镇关西");
        System.out.println("大闹野猪林");
        System.out.println("倒拔垂杨柳");
        System.out.println("黑马学Java");
    }
}

class 唐僧 extends 和尚Adapter {
    @Override
    public void 打坐() {
        super.打坐();
    }

    @Override
    public void 念经() {
        super.念经();
    }

    @Override
    public void 撞钟() {
        super.撞钟();
    }
}

7. 模版设计模式

package com.itheima.template;

public abstract class CompositionTemplate {

    public final void write(){// 使用final修饰, 避免被重写导致逻辑错误
        System.out.println("我的爸爸");

        body();

        System.out.println("啊~ 这就是我的爸爸~");
    }

    abstract public void body();
}

package com.itheima.template;

public class Tom extends CompositionTemplate{

    @Override
    public void body() {
        System.out.println("我的爸爸是一个争强好胜的人, 每天晚上忙到很晚, 才陆陆续续的回家");
    }
}

package com.itheima.template;

public class Test {
    public static void main(String[] args) {
        Tom t = new Tom();
        t.write();
    }
}