Java（十二）

知识点1：final关键字的使用

package com.atguigu.java;

/**
 *
 * final关键字的使用
 *
 * 1.final : 最终的
 * 2. 可以用来修饰：类、方法、变量（属性、局部变量）
 *
 * 3. final修饰类：表示此类不能被继承。
 *   比如：String\StringBuffer\StringBuilder
 *
 * 4. final修饰方法：表示此方法不能被重写
 *   比如：Object类中getClass()
 *
 * 5.1 final修饰属性：此属性是一个常量。
 *    表示：此属性一旦被赋值，就不可更改。即：只能赋值一次。
 *    final修饰的属性可以在哪些位置赋值？① 显式赋值 ② 代码块中赋值 ③构造器中赋值
 *
 *    说明： static final修饰一个属性：全局常量。
 *    比如：Math类中的PI
 *        在游戏中：public static final int UP = 1;
 *                 public static final int DOWN = 2;
 *                 public static final int LEFT = 3;
 *                 public static final int RIGHT = 4;
 *
 *
 * 5.2 final修饰局部变量：一旦对此局部变量进行了赋值，就不能再修改此值。
 *
 *
 *  面试题：区分 final \ finalize \ finally
 */
public class FinalTest {

    public static void main(String[] args) {
        FinalTest test = new FinalTest();
        test.method1(10);
    }

    final int MY_NUM1 = 0;

    final int NUM2;

    {
        NUM2 = 1;
    }

    final int NUM3;

    public FinalTest(){
        NUM3 = 3;
    }

    public FinalTest(int i){
//        this();
        NUM3 = i;
    }

//    final int NUM4;
//
//    public void setNum4(int num4){
//        this.NUM4 = num4;
//    }


    public void method(){
        final int num = 0;
//        num++;
        System.out.println(num);
    }

    public void method1(final int num){
//        num++;
        System.out.println(num);
    }
}

//class MyString extends String{}

final class A{

}

//class B extends  A{
//
//}

class C{
    public final void methodFinal(){}
}

class D extends C{
//    public void methodFinal(){}
}

说明：开发中我们常关注使用final修饰属性。

知识点2：abstract关键字的使用

• 产生的背景

• 知识点说明

/**
 *
 * abstract class Account{
 *     double balance;//余额
 *
 *     public void withdraw(double amt){}
 *
 *     public void deposit(double amt){}
 *
 * }
 *
 * class SavingAccount extends Account{
 *
 * }
 *
 * class CheckAccount extends Account{
 *
 * }
 *
 *
 *
 *
 * abstract关键字的使用
 * 1. abstract:抽象的
 * 2. abstract用来修饰类、方法
 *
 * 3. abstract修饰类：此时就是抽象类
 *      > 抽象类，不可以实例化。
 *      > 开发中，我们都会去提供抽象类的子类。进而创建子类的实例。
 *
 *
 * 4. abstract修饰方法：即为抽象方法
 *      > 抽象方法所在的类，一定是抽象类。反之，抽象类中可以没有抽象方法。
 *      > 子类继承抽象的父类以后，如果重写了抽象的父类中的所有的抽象方法，则此子类可以实例化。
 *        子类继承抽象的父类以后，没有重写抽象的父类中的所有的抽象方法，则此子类仍然为抽象类。
 *
 *
 */

• 代码演示

public class AbstractTest {
    public static void main(String[] args) {
//        Person p1 = new Person();
//        p1.eat();

        Student s1 = new Student();
        s1.eat();
        s1.sleep();


        //创建了继承于Person类的匿名子类的对象
        Person p2 = new Person(){

            @Override
            public void eat() {

            }

            @Override
            public void sleep() {

            }

            @Override
            public void breath() {

            }
        };
        System.out.println(p2.getClass());
    }
}

abstract class Creature{
    public abstract void breath();//呼吸
}

abstract class Person extends Creature{
    String name;
    int age;

    //抽象方法
    public abstract void eat();

    public abstract void sleep();
}

class Student extends Person{
    String major;

    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }

    @Override
    public void sleep() {
        System.out.println("学生保证每天8小时的睡眠");
    }


    @Override
    public void breath() {
        System.out.println("学生多呼吸新鲜空气");
    }
}

abstract class Worker extends Person{
    @Override
    public void breath() {
        System.out.println("工人的工作场所空气质量一般都不好");
    }
}

• 应用场景

• abstract使用的注意点

/**
 *
 * 1. abstract只能修饰类、方法；不能修饰属性、构造器、代码块
 *
 * 2. 不能用abstract修饰私有方法、静态方法、final的方法、final的类
 */
public abstract class AbstractTest1 {
    public abstract void method();
}

知识点3：接口的使用

• 知识点说明

/**
 *
 * interface关键字的使用
 *
 * 1. 使用interface定义接口，接口是与类并列的概念
 *
 * 2. 接口内可以声明的结构有：
 *   jdk7及以前：全局常量、抽象方法
 *   全局常量：public static final 。可以省略不写
 *   抽象方法：public abstract 。可以省略不写
 *
 *  jdk8中：接口中定义静态方法、默认方法
 *  jdk9中：接口中定义私有方法
 *
 * 3. 接口中不能定义构造器，不能实例化接口！
 *
 * 4. 类与接口之间是实现(implements)关系，而且是多实现的。
 *    class A extends B implements C,D
 *
 *    4.1 如果实现类实现了接口中声明的所有抽象方法，则此类可以实例化
 *    4.2 如果实现类没有实现接口中声明的所有抽象方法，则此类仍为抽象类，不能实例化
 *
 * 5. 接口与接口之间存在继承关系，而且是可以多继承的。
 */

• 代码演示

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MIN_SPEED);
        System.out.println(Flyable.MAX_SPEED);

        System.out.println(Bullet.MIN_SPEED);
    }
}

interface Flyable{
    //常量
    public static final int MIN_SPEED = 1;
    int MAX_SPEED = 7900;

    void fly();
}

interface Attackable{
    void attack();
}

abstract class Plane implements Flyable{

}

class Bullet implements Flyable,Attackable{

    @Override
    public void fly() {
        System.out.println("让子弹飞一会儿~~");
    }

    @Override
    public void attack() {
        System.out.println("子弹具备攻击性");
    }
}

//#####################

interface AA{
    void method1();
}
interface BB{
    void method2();
}

interface CC extends AA,BB{

}

class DD implements CC{

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

• 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

• 经典题目

package com.atguigu.java1;

/**
 *
 * 1. 接口，定义了一种规范、标准
 *
 * 2. 接口也存在多态性
 *
 */
public class USBTest {

    public static void main(String[] args) {
        Computer computer = new Computer();

        Printer printer = new Printer();
        //1. 传入接口的实现类的对象
        computer.transferData(printer);

        //2.传入接口的实现类的匿名对象
        computer.transferData(new Flash());

        //3.传入接口的匿名实现类的对象
        USB usb1 = new USB(){

            @Override
            public void start() {
                System.out.println("数码相机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("数码相机结束工作");
            }
        };
        computer.transferData(usb1);

        //4.传入接口的匿名实现类的匿名对象
        computer.transferData(new USB(){

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }
        });


    }

}

interface USB{
    //常量：USB的长、宽、...
    //抽象方法
    public abstract void start();
    void stop();
}

class Computer{

    public void transferData(USB usb){//多态：USB usb = new Printer();
        usb.start();
        System.out.println("=======数据传输的细节==========");
        usb.stop();
    }

}

class Printer implements USB{//打印机

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机停止工作");
    }
}

class Flash implements USB{//u盘
    @Override
    public void start() {
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘停止工作");
    }
}

• java8中的新特性

package com.atguigu.java2;

/**
 */
public interface CompareA {
    public static void method1(){
        System.out.println("CompareA:北京");
    }

    public default void method2(){
        System.out.println("CompareA:上海");
    }

    default void method3(){
        System.out.println("CompareA:深圳");
    }

    default void method4(){
        System.out.println("CompareA:广州");
    }
}

package com.atguigu.java2;

/**
 */
public interface CompareB {
    default void method3(){
        System.out.println("CompareB:深圳");
    }
}
package com.atguigu.java2;

/**
 */
public class SuperClass {
    public void method4(){
        System.out.println("SuperClass:广州");
    }
}

package com.atguigu.java2;

/**
 */
public class SubClass extends SuperClass implements CompareA,CompareB {

    public void method2(){
        System.out.println("SubClass:上海");
    }

    public void method3(){
        System.out.println("SubClass:深圳");
    }



    //知识点5：如何调用父类及实现的接口中被重写的方法。
    public void method(){
        super.method4();//调用的是父类中的方法
        method3();//SubClass自己重写的方法
        CompareA.super.method2();//调用的是接口中的方法

    }
}

package com.atguigu.java2;

import org.junit.Test;

/**
 */
public class SubClassTest {
    public static void main(String[] args) {
        //知识点1：接口中的静态方法不能被实现类直接调用。只能通过接口来进行调用。
        CompareA.method1();
        //编译不通过
//        SubClass.method1();

        //知识点2：通过实现类的对象可以直接调用接口中定义的默认方法。
        //如果实现类重写了接口中的默认方法，则实现类对象调用的就是重写的方法
        SubClass sub1 = new SubClass();
        sub1.method2();

        //知识点3：如果实现类实现的多个接口中，定义了同名同参数的默认方法，则实现类必须要重写
        //接口中的此方法。否则会出现接口冲突。
        sub1.method3();

    }
    //知识点4：如果子类继承的父类与实现的接口中定义了同名同参数的方法，则子类在没有重写此方法的
    //情况下，默认调用父类中的方法。---->类优先原则。
    @Test
    public void test1(){
        SubClass sub1 = new SubClass();
        sub1.method4();
    }
}

知识点4：内部类的使用

• 知识点总结

/**
 *
 * 类的成员之五：内部类
 *
 * 1. 概念：将一个类A声明在另一个类B的内部，则构成了内部类结构。
 *
 * 2. 分类：成员内部类 ：静态的成员内部类  vs 非静态的成员内部类
 *          局部内部类：
 *
 * 3. 内部类，一方面作为类：
 *              > 可以定义属性、方法、构造器、代码块等
 *              > 可以被final、abstract 修饰
 *
 *          另一方面作为外部类的成员：
 *              > 可以被4种权限修饰符修饰。
 *              > 可以被static修饰
 *              > 可以调用外部类的属性、方法等。
 *
 *
 *  4. 需要大家掌握的3个知识点：
 *    ① 如何创建成员内部类的对象？（静态的成员内部类、非静态的成员内部类）
 *    ② 在成员内部类中，如何调用外部类的结构。
 *    ③ 掌握局部内部类的常见使用场景:见 InnerClassTest1.java
 */

• 代码演示

public class InnerClassTest {
    public static void main(String[] args) {
        //创建静态的成员内部类的对象
       Person.Cat cat =  new Person.Cat();

       //创建非静态的成员内部类的对象
        Person p1 = new Person();
        Person.Dog dog = p1.new Dog(); //new p1.Dog():错误的

        dog.info("花花");

        dog.eat();

        System.out.println(dog.getClass());
    }
}

class Person{
    String name = "Tom";
    int age;

    //内部类
    public class Dog{
        String name = "旺财";

        public void eat(){
            swim();
            Person.this.swim();
        }

        public void info(String name){
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(Person.this.name);
        }

        public void swim(){
            System.out.println("狗也会游泳");
        }
    }

    static class Cat{

    }

    public void method(){
        //内部类
        class AA{

        }
    }

    public void swim(){
        System.out.println("人游泳");
    }

}

• 内部类的使用举例

/**
 *
 * 局部内部类的使用
 */
public class InnerClassTest1 {

    public void method(){
        //局部内部类：非常少见
        class AA{

        }
    }

    public Comparable getComparable(){
        //局部内部类
//        class MyComparable implements Comparable{
//
//            @Override
//            public int compareTo(Object o) {
//                return 0;
//            }
//        }
//        return new MyComparable();


        return new Comparable(){

            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}