Java学习笔记七、面向对象编程高级部分

最新推荐文章于 2024-09-05 10:39:00 发布

XD Wen

最新推荐文章于 2024-09-05 10:39:00 发布

阅读量813

点赞数 1

分类专栏： Java学习笔记文章标签： java 开发语言后端学习

本文链接：https://blog.csdn.net/qq_43681634/article/details/123669289

版权

Java学习笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的
对象去访问它时,取到的都是相同的值同样任何个该类的对象去修改它时,修改
的也是同一个变量。

访问修饰符 static 数据类型 变量名; [推荐]
static 访问修饰符 数据类型 变量名;

类名.类变量名;[推荐]
对象名.类变量名;[静态变量的访问修饰符的访问权限和范围 和普通属性是样的。]

类变量使用注意事项和细节讨论

什么时候需要用类变量
当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态
变量)
类变量与实例变量(普通属性)区别
类变量是该类的所有对象共享的，而实例变量是每个对象独享的。
加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
类变量可以通过类名.类变量名或者对象名.类变量名来访问，但java设计者推荐
我们使用类名.类变量名方式访问。[前提是满足访问修饰符的访向权限和范围]
实例变量不能通过类名类变量名方式访问。
类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，
就可以使用类变量了。
类变量的生命周期是随类的加载开始，随着类消亡而销毁。

package com.edu.static_;

public class StaticDetail {
    public static void main(String[] args) {
        B b = new B();
        //System.out.println(B.n1);
        System.out.println(B.n2);
        //静态变量是类加载的时候，就创建了,所以我们没有创建对象实例
        //也可以通过类名.类变量名来访问
        System.out.println(C.address);
    }
}

class B {
    public int n1 = 100;
    public static int n2 = 200;
}

class C {
    public static String address = "北京";
}

类方法

类方法也叫静态方法。

访问修饰符 static 数据返回类型 方法名(){ } [推荐]
static 访问修饰符 数据返回类型 方法名(){ }

类名.类方法名;
对象名.类方法名;[前提是 满足访问修饰符的访问权限和范围]

类方法使用注意事项和细节讨论

类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区:
类方法中无this的参数
普通方法中隐含着this的参数
类方法可以通过类名调用，也可以通过对象名调用
普通方法和对象有关，需要通过对象名调用，如对象名.方法名(参数)，不能通过类名调用
类方法中不允许使用和对象有关的关键字，比如this和super. 普通方法(成员方法)可以
类方法(静态方法)中只能访问静态变量或静态方法
普通成员方法，既可以访问非静态成员，也可以访问静态成员。
小结: 静态方法，只能访问静态的成员,
非静态的方法，可以访问静态成员和非静态成员(必须遵守访问权限)

package com.edu.static_;

public class StaticMethodDetail {
    public static void main(String[] args) {
        D.hi();//ok
        //非静态方法，不能通过类名调用
        //D.say();, 错误，需要先创建对象，再调用
        new D().say();//可以
    }
}

class D {
    private int n1 = 100;
    private static int n2 = 200;

    public void say() {//非静态方法,普通方法
    }

    public static void hi() {//静态方法,类方法
        //类方法中不允许使用和对象有关的关键字，
        //比如 this 和 super。普通方法(成员方法)可以。
        //System.out.println(this.n1);//错误
    }

    //类方法(静态方法)中 只能访问 静态变量 或静态方法
    //口诀:静态方法只能访问静态成员.
    public static void hello() {
        System.out.println(n2);
        System.out.println(D.n2);
        //System.out.println(this.n2);不能使用
        hi();//OK
        //say();//错误
    }

    //普通成员方法，既可以访问 非静态成员，也可以访问静态成员
    //小结: 非静态方法可以访问 静态成员和非静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}

理解main方法

解释main方法的形式: public static void main(String[] args){}

main方法时虚拟机调用
java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所
运行的类的参数,案例演示，接收参数.
java执行的程序参数1参数2参数3

main方法特别提示

在 main()方法中，我们可以直接调用 main 方法所在类的静态方法或静态属性。
但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员

package com.edu.main_;

public class Main01 {
    //静态的变量/属性
    private static String name = "教育";

    //非静态的变量/属性
    private int n1 = 10000;

    //静态方法
    public static void hi() {
        System.out.println("Main01 的 hi 方法");
    }

    //非静态方法
    public void cry() {
        System.out.println("Main01 的 cry 方法");
    }

    public static void main(String[] args) {
        //可以直接使用 name
        //1. 静态方法 main 可以访问本类的静态成员
        System.out.println("name=" + name);
        hi();

        //2. 静态方法 main 不可以访问本类的非静态成员
        //System.out.println("n1=" + n1);//错误
        //cry();//错误

        //3. 静态方法 main 要访问本类的非静态成员，需要先创建对象 , 再调用即可
        Main01 main01 = new Main01();
        System.out.println(main01.n1);//ok
        main01.cry();
    }
}

代码块

代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

[修饰符]{
	代码
}

说明注意:

修饰符可选，要写的话，也只能写static
代码块分为两类，使用static 修饰的叫静态代码块，
没有static修饰的，叫普通代码块/非静态代码块。
逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
;号可以写上，也可以省略。

代码块的好处

相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
场景:如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

代码块使用注意事项和细节讨论

static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
类什么时候被加载[重要]
①创建对象实例时(new)
②创建子类对象实例，父类也会被加载
③使用类的静态成员时(静态属性，静态方法)
普通的代码块，在创建对象实例时，会被隐式的调用。
被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行。
小结:
1.static代码块是类加载时，执行，只会执行次
2.普通代码块是在创建对象时调用的，创建一次，调用次
3.类加载的3种情况，需要记住

package com.edu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1. 创建对象实例时(new)
        // AA aa = new AA();
        //2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
        // AA aa2 = new AA();
        //3. 使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.n1);
        //static 代码块，是在类加载时，执行的，而且只会执行一次.
        // DD dd = new DD();
        // DD dd1 = new DD();
        //普通的代码块，在创建对象实例时，会被隐式的调用。
        // 被创建一次，就会调用一次。
        // 如果只是使用类的静态成员时，普通代码块并不会执行
        System.out.println(DD.n1);//8888, 静态模块块一定会执行
    }
}
class DD {
    public static int n1 = 8888;//静态属性
    //静态代码块
    static {
        System.out.println("DD 的静态代码 1 被执行...");//
    }
    //普通代码块, 在 new 对象时，被调用，而且是每创建一个对象，就调用一次
    //可以这样简单的，理解 普通代码块是构造器的补充
    {
        System.out.println("DD 的普通代码块...");
    }
}
class Animal {
    //静态代码块
    static {
        System.out.println("Animal 的静态代码 1 被执行...");//
    }
}
class Cat extends Animal {
    public static int n1 = 999;//静态属性
    //静态代码块
    static {
        System.out.println("Cat 的静态代码 1 被执行...");//
    }
}
class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码 1 被执行...");//1
    }
}
class AA extends BB {
    //静态代码块
    static {
        System.out.println("AA 的静态代码 1 被执行...");//2
    }
}

创建一个对象时，在一个类调用顺序是(重点) :
①调用静态代码块和静态属性初始化
(注意:静态代码块和静态属性初始化调用的优先级一样，
如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
②调用普通代码块和普通属性的初始化
(注意:普通代码块和普通属性初始化调用的优先级一样，
如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
③调用构造方法。

package com.edu.codeblock_;

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
        // (1) A 静态代码块 01
        // (2) getN1 被调用...
        // (3)A 普通代码块 01
        // (4)getN2 被调用...
        // (5)A() 构造器被调用
    }
}
class A {
    { //普通代码块
        System.out.println("A 普通代码块 01");
    }
    private int n2 = getN2();//普通属性的初始化
    static { //静态代码块
        System.out.println("A 静态代码块 01");
    }
    //静态属性的初始化
    private static int n1 = getN1();
    public static int getN1() {
        System.out.println("getN1 被调用...");
        return 100;
    }
    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2 被调用...");
        return 200;
    }
    //无参构造器
    public A() {
        System.out.println("A() 构造器被调用");
    }
}

构造器的最前面其实隐含了super(和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕因此是优先于构造器和普通代码块执行的

class A {
public A( {//构造器
	//这里有隐藏的执行要求
	//(1) super()
	//(2)调用普通代码块的
	System.out.println(" ok");
}

package com.edu.codeblock_;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB();
        //(1)AAA 的普通代码块
        // (2)AAA() 构造器被调用
        // (3)BBB 的普通代码块
        // (4)BBB() 构造器被调用
    }
}
class AAA { //父类 Object
    {
        System.out.println("AAA 的普通代码块");
    }
    public AAA() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("AAA() 构造器被调用....");
    }
}
class BBB extends AAA {
    {
        System.out.println("BBB 的普通代码块...");
    }
    public BBB() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("BBB() 构造器被调用....");
    }
}

创建一一个子类对象时(继承关系)，他们的静态代码块，静态属性初
始化，普通代码块，普通属性初始化，构造方法的调用顺序如下:
①父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
②子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
③父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
④父类的构造方法
⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
⑥子类的构造方法
静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调
用任意成员

package com.edu.codeblock_;

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //(1) 进行类的加载
        //1.1 先加载 父类 A02 1.2 再加载 B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        //new B02();//对象
        new C02();
    }
}
class A02 { //父类
    private static int n1 = getVal01();
    static {
        System.out.println("A02 的一个静态代码块..");//(2)
    }
    {
        System.out.println("A02 的第一个普通代码块..");//(5)
    }
    public int n3 = getVal02();//普通属性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }
    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化...... System.out.println("A02 的构造器");//(7)
    }
}
class C02 {
    private int n1 = 100;
    private static int n2 = 200;
    private void m1() {
    }
    private static void m2() {
    }

    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }
    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}
class B02 extends A02 { //
    private static int n3 = getVal03();
    static {
        System.out.println("B02 的一个静态代码块..");//(4)
    }
    public int n5 = getVal04();
    {
        System.out.println("B02 的第一个普通代码块..");//(9)
    }
    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }
    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //public B02() {//构造器
    //隐藏了
    //super()
    //普通代码块和普通属性的初始化... System.out.println("B02 的构造器");//(10)
    // TODO Auto-generated constructor stub
    //}
}

单例设计模式

所谓类的单例(单个的实例)设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
单例模式有两种方式 1)饿汉式2)懒汉式

单例模式应用实例

构造器私有化=》防止直接new
类的内部创建对象
向外暴露一个静态的公共方法。getInstance

package com.edu.single_;

/*
 * 饿汉式
 */
public class SingleTon01 {

    public static void main(String[] args) {
        // GirlFriend xh = new GirlFriend("小红");
        // GirlFriend xb = new GirlFriend("小白");
        //通过方法可以获取对象
        GirlFriend instance = GirlFriend.getInstance();
        System.out.println(instance);
        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance2);
        System.out.println(instance == instance2);//T
        //System.out.println(GirlFriend.n1);
        //... }
    }

    //有一个类， GirlFriend
    //只能有一个女朋友
    static class GirlFriend {
        private String name;

        //public static int n1 = 100;
        //为了能够在静态方法中，返回 gf 对象，需要将其修饰为 static
        //對象，通常是重量級的對象, 餓漢式可能造成創建了對象，但是沒有使用.
        private static GirlFriend gf = new GirlFriend("小红红");
        //如何保障我们只能创建一个 GirlFriend 对象
        //步骤[单例模式-饿汉式]
        //1. 将构造器私有化
        //2. 在类的内部直接创建对象(该对象是 static)
        //3. 提供一个公共的 static 方法，返回 gf 对象
        private GirlFriend(String name) {
            System.out.println("構造器被調用.");
            this.name = name;
        }

        public static GirlFriend getInstance() {
            return gf;
        }

        @Override
        public String toString() {
            return "GirlFriend{" +
                    "name='" + name + '\'' +
                    '}';
        }

    }
}

package com.edu.single_;

/**
 * 懒汉式
 */
public class SingleTon02 {
    public static void main(String[] args) {
        //new Cat("大黃");
        //System.out.println(Cat.n1);
        Cat instance = Cat.getInstance();
        System.out.println(instance);
        //再次調用 getInstance
        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);
        System.out.println(instance == instance2);//T
    }
}
    //希望在程序運行過程中，只能創建一個 Cat 對象

//使用單例模式
class Cat {
    private String name;
    public static int n1 = 999;
    private static Cat cat ; //默認是 null
    //步驟
    //1.仍然構造器私有化
    //2.定義一個 static 靜態屬性對象
    //3.提供一個 public 的 static 方法，可以返回一個 Cat 對象
    //4.懶漢式，只有當用戶使用 getInstance 時，才返回 cat 對象, 後面再次調用時，會返回上次創建的 cat 對象
    // 從而保證了單例
    private Cat(String name) {
        System.out.println("構造器調用...");
        this.name = name;
    }
    public static Cat getInstance() {
        if(cat == null) {//如果還沒有創建 cat 對象
            cat = new Cat("小可愛");
        }
        return cat;
    }
    @Override
    public String toString() {

        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

饿汉式VS懒汉式

二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建。
饿汉式不存在线程安全问题，懒汉式存在线程安全问题。
饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
在javaSE标准类中，java.lang.Runtime就是经典的单例模式。

final关键字

final可以修饰类、属性、方法和局部变量.
在某些情况下,有以下需求，就会使用到final:

当不希望类被继承时,可以用final修饰
当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰
当不希望类的的某个属性的值被修改,可以用final修饰
当不希望某个局部变量被修改，可以使用final修饰

final 使用注意事项和细节讨论

final修饰的属性又叫常量一般用XX XX XX来命名
final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一[选择一个位置赋初值即可] :
①定义时:如public final double TAX RATE=0.08;
②在构造器中
③在代码块中。
如果final修饰的属性是静态的，则初始化的位置只能是
①定义时
②在静态代码块不能在构造器中赋值
final类不能继承，但是可以实例化对象
如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可
以被继承

package com.edu.final_;

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();
        new EE().cal();
    }
}
class AA {
    /*
    1. 定义时：如 public final double TAX_RATE=0.08;
    2. 在构造器中
    3. 在代码块中
    */
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2 ;
    public final double TAX_RATE3 ;
    public AA() {//构造器中赋值
        TAX_RATE2 = 1.1;
    }
    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }
}
class BB {
    /*
    如果 final 修饰的属性是静态的，则初始化的位置只能是
    1 定义时 2 在静态代码块 不能在构造器中赋值。
    */
    public static final double TAX_RATE = 99.9;
    public static final double TAX_RATE2 ;
    static {
        TAX_RATE2 = 3.3;
    }
}
//final 类不能继承，但是可以实例化对象
final class CC { }
//如果类不是 final 类，但是含有 final 方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制.
class DD {
    public final void cal() {
        System.out.println("cal()方法");
    }
}
class EE extends DD { }

一般来说，如果个类已经是final类了,就没有必要再将方法修饰成final方法
final不能修饰构造方法(即构造器)
final和static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
包装类(Integer, Double,Float, Boolean等都是final),String也是final类

package com.edu.final_;

public class FinalDetail02 {
    public static void main(String[] args) {
        System.out.println(BBB.num);
        //包装类,String 是 final 类，不能被继承
    }
}
//final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class BBB {
    public final static int num = 10000;
    static {
        System.out.println("BBB 静态代码块被执行");
    }
}
final class AAA{
    //一般来说，如果一个类已经是 final 类了，就没有必要再将方法修饰成 final 方法
    //public final void cry() {}
}

抽象类

用abstract关键字来修饰一个类时，这个类就叫抽象类

访问修饰符 abstract 类名{
}

用abstract关键字来修饰一个方法时，这个方法就是抽象方法

访问修饰符 abstract 返回类型 方法名(参数列表);//没有方法体

抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类
抽象类，是考官比较爱问的知识点在框架和设计模式使用较多

抽象类使用的注意事项和细节讨论

抽象类不能被实例化
抽象类不一定要包含abstract方法。
也就是说，抽象类可以没有abstract方法
一旦类包含了abstract方法,则这个类必须声明为abstract
abstract只能修饰类和方法，不能修饰属性和其它的。

package com.edu.abstract_;

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类，不能被实例化
        //new A();
    }
}
//抽象类不一定要包含 abstract 方法。也就是说,抽象类可以没有 abstract 方法,还可以有实现的方法。
abstract class A {
    public void hi() {
        System.out.println("hi");
    }
}
//一旦类包含了 abstract 方法,则这个类必须声明为 abstract
abstract class B {
    public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
// public abstract int n1 = 1;
}

抽象类可以有任意成员 [抽象类本质还是类] ,比如: 非抽象方法、
构造器、静态属性等等
抽象方法不能有主体，即不能实现
如果个类继承了抽象类，则它必须实现抽象类的所有抽象方法，
除非它自己也声明为abstract类
抽象方法不能用private、final和static来修饰，这些关键字和重写相违背的

package com.edu.abstract_;

public class AbstractDetail02 {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}
//抽象方法不能使用 private、final 和 static 来修饰，因为这些关键字都是和重写相违背的
abstract class H {
    public abstract void hi();//抽象方法
}
//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为 abstract 类
abstract class E {
    public abstract void hi();
}

abstract class F extends E { }

class G extends E {
    @Override
    public void hi() { //这里相等于 G 子类实现了父类 E 的抽象方法，所谓实现方法，就是有方法体
    }
}
//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    public int n1 = 10;
    public static String name = "学习";
    public void hi() {
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok() {
        System.out.println("ok");
    }
}

接口

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候,在根据具体情况把这些方法写出来。

//语法:
interface接口名{
	//属性
	//抽象方法
}
class类名implements接口{
	//自己属性;
	//自己方法;
	//必须实现的接口的抽象方法
}

小结:接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体[jdk7.0]。接口体现了程序设计的多态和高内聚低偶合的设计思想。
特别说明: Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

注意事项和细节

接口不能被实例化
接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修

void aaa();
//实际上是
abstract void aa();

一个普通类实现接口,就必须将该接口的所有方法都实现。
抽象类实现接口，可以不用实现接口的方法。

package com.edu.interface_;

public class InterfaceDetail01 {
    public static void main(String[] args) {
        //new IA();
    }
}
//1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法，可以不用 abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,IDEA中可以使用 alt+enter 来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//修饰符 public protected 默认 private
    void hi();
}
class Cat implements IA{
    @Override
    public void say() {
    }
    @Override
    public void hi() {
    }
}
abstract class Tiger implements IA {
}

一个类同时可以实现多个接口
接口中的属性，只能是final的，而且是public static final修饰符。
比如:int a= 1;实际上是public static final int a= 1; (必须初始化)
接口中属性的访问形式:接口名.属性名
接口不能继承其它的类,但是可以继承多个别的接口
接口的修饰符只能是public和默认，这点和类的修饰符是一样的

package com.edu.interface_;

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //老韩证明 接口中的属性,是 public static final
        System.out.println(IB.n1);//说明 n1 就是 static
        //IB.n1 = 30; 说明 n1 是 final
    }
}
interface IB {
    //接口中的属性,只能是 final 的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}
interface IC {
    void say();
}

//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE{}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

接口和继承

接口和继承解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性。
接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法。即
更加的灵活…

接口比继承更加灵活
接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足like - a的关系
接口在一定程度上实现代码解耦[即:接口规范性+动态绑定机制]

当子类继承了父类，就自动的拥有父类的功能
如果子类需要扩展功能，可以通过实现接口的方式扩展.
可以理解实现接口是对 java 单继承机制的一种补充

内部类

一个类的内部又完整的嵌套了另个类结构。被嵌套的类称为内部类(inner class) ，嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员[类的五大成员是哪些?[属性、方法、构造器、代码块、内部类]]，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

如果定义类在局部位置(方法中/代码块) :(1)局部内部类(2) 匿名内部类
定义在成员位置(1) 成员内部类(2)静态内部类

Class Outer{ //外部类
	class Inner{
	//内部类
	}
}

局部内部类的使用

局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

可以直接访问外部类的所有成员，包含私有的
不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
作用域:仅仅在定义它的方法或代码块中。
局部内部类-- -访问----外部类的成员[访问方式:直接访问]
外部类—访问---->局部内部类的成员
访问方式:创建对象，再访问(注意:必须在作用域内)
(1)局部内部类定义在方法中/代码块
(2) 作用域在方法体或者代码块中
(3)本质仍然是一一个类
外部其他类—不能访问---->局部内部类(因为局部内部类地位是一个局部变量)
如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问
System.out.println( "外部类的n2=”+外部类名.this.n2);

package com.edu.innerclass_;

/**
 * 局部内部类的使用
 */
public class LocalInnerClass {//
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02 的 hashcode=" + outer02);
    }
}
class Outer02 {//外部类
    private int n1 = 100;
    private void m2() {
        System.out.println("Outer02 m2()");
    }//私有方法
    public void m1() {//方法
        //1.局部内部类是定义在外部类的局部位置,通常在方法
        //3.不能添加访问修饰符,但是可以使用 final 修饰
        //4.作用域 : 仅仅在定义它的方法或代码块中
        final class Inner02 {//局部内部类(本质仍然是一个类)
            //2.可以直接访问外部类的所有成员，包含私有的

            private int n1 = 800;
            public void f1() {
                //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类 n1 和 m2()
                //7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，
                // 如果想访问外部类的成员，使用 外部类名.this.成员）去访问
                // Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的 n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
        //6. 外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

匿名内部类的使用(重要)

(1)本质是类(2)内部类(3)该类没有名字(4)同时还是一个对象
说明:匿名内部类是定义在外部类
的局部位置，比如方法中，并且没有类名

匿名内部类的基本语法

new类或接口(参数列表){
	类体
};

package com.edu.innerclass_;

/**
 * 匿名内部类的使用
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04 { //外部类
    private int n1 = 10;//属性
    public void method() {//方法
        //基于接口的匿名内部类
        //1.需求： 想使用 IA 接口,并创建对象
        //2.传统方式，是写一个类，实现该接口，并创建对象
        //3.需求是 Tiger/Dog 类只是使用一次，后面再不使用
        //4.可以使用匿名内部类来简化开发
        //5.tiger 的编译类型 ? IA
        //6.tiger 的运行类型 ? 就是匿名内部类 Outer04$1
        /*
        看底层 会分配 类名 Outer04$1
        class Outer04$1 implements IA {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        }
        */
        //7. jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址返回给 tiger
        //8. 匿名内部类使用一次，就不能再使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger 的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();



        //演示基于类的匿名内部类
        //1. father 编译类型 Father
        //2. father 运行类型 Outer04$2
        //3. 底层会创建匿名内部类
        /*
        class Outer04$2 extends Father{
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        }
        */
        //4. 同时也直接返回了 匿名内部类 Outer04$2 的对象
        //5. 注意("jack") 参数列表会传递给 构造器
        Father father = new Father("jack"){
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        };
        System.out.println("father 对象的运行类型=" + father.getClass());//Outer04$2
        father.test();



        //基于抽象类的匿名内部类
        Animal animal = new Animal(){
            @Override
            void eat() {
                System.out.println("小狗吃骨头...");
            }
        };
        animal.eat();
    }
}
interface IA {//接口
    public void cry();
}

class Father {//类

    public Father(String name) {//构造器
        System.out.println("接收到 name=" + name);
    }
    public void test() {//方法
    }
}
abstract class Animal { //抽象类
    abstract void eat();
}

匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建
对象的特征，因此可以调用匿名内部类方法
可以直接访问外部类的所有成员，包含私有的
不能添加访问修饰符，因为它的地位就是一个局部变量。
作用域:仅仅在定义它的方法或代码块中。
匿名内部类—访问---->外部类成员[访问方式:直接访问]
外部其他类—不能访问---->匿名内部类(因为匿名内部类地位是一一个局部变量)
如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问

package com.edu.innerclass_;

public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
        //外部其他类---不能访问----->匿名内部类
        System.out.println("main outer05 hashcode=" + outer05);
    }
}

class Outer05 {
    private int n1 = 99;
    public void f1() {
        //创建一个基于类的匿名内部类
        //不能添加访问修饰符,因为它的地位就是一个局部变量
        //作用域 : 仅仅在定义它的方法或代码块中
        Person p = new Person(){
            private int n1 = 88;
            @Override
            public void hi() {
            //可以直接访问外部类的所有成员，包含私有的
            //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
                System.out.println("匿名内部类重写了 hi 方法 n1=" + n1 +
                        " 外部内的 n1=" + Outer05.this.n1 );
            //Outer05.this 就是调用 f1 的 对象
                System.out.println("Outer05.this hashcode=" + Outer05.this);
            }
        };

        p.hi();//动态绑定, 运行类型是 Outer05$1
        //也可以直接调用, 匿名内部类本身也是返回对象
//         class 匿名内部类 extends Person {}
//         new Person(){
//             @Override
//             public void hi() {
//                System.out.println("匿名内部类重写了 hi 方法,哈哈...");
//             }
//             @Override
//             public void ok(String str) {
//                  super.ok(str);
//             }
//         }.ok("jack");
            }
        }
class Person {//类
    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok(String str) {

        System.out.println("Person ok() " + str);
    }
}
//抽象类/接口...

成员内部类的使用

成员内部类是定义在外部类的成员位置，并且没有static修饰。

可以直接访问外部类的所有成员，包含私有的
可以添加任意访问修饰符(public、 protected、默认、private),因为它的地
位就是一个成员。
作用域和外部类的其他成员一样，为整个类体
成员内部类— 访—>外部类成员(比如:属性) [访问方式直接访问]
外部类- ------成员内部类(说明)访问方式：创建对象，再访问
外部其他类—访向----成员内部类
如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问

package com.edu.innerclass_;

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        //外部其他类，使用成员内部类的三种方式
        // 第一种方式
        // outer08.new Inner08(); 相当于把 new Inner08()当做是 outer08 成员
        // 这就是一个语法，不要特别的纠结.
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        // 第二方式 在外部类中，编写一个方法，可以返回 Inner08 对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}

class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";
    private void hi() {
        System.out.println("hi()方法...");
    }
    //1.注意: 成员内部类，是定义在外部内的成员位置上
    //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;
        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则. 
            // 可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
            hi();
        }
    }
    //方法，返回一个 Inner08 实例
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
    //写方法
    public void t1() {
    //使用成员内部类
    //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

静态内部类的使用

静态内部类是定义在外部类的成员位置，并且有static修饰

可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
可以添加任意访问修饰符(public、 protected、默认、private),因为它的地位就是一个成员。
作用域:同其他的成员，为整个类体
静态内部类—访问----> 外部类(比如:静态属性) [访问方式:直接访问所有静态成员]
外部类—访问----->静态内部类访问方式:创建对象，再访问
外部其他类–访问---->静态内部类
如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员) 去访问

package com.edu.innerclass_;

public class StaticInnerClass {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
        //外部其他类 使用静态内部类

        //方式 1
        //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式 2
        //编写一个方法，可以返回静态内部类的对象实例.
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();
        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("************");
        inner10_.say();
    }
}

class Outer10 { //外部类
    private int n1 = 10;
    private static String name = "张三";
    private static void cry() {}
    //Inner10 就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用 static 修饰
    //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner10 {
        private static String name = "学习";
        public void say() {
        //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
        //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类 name= " + Outer10.name);
            cry();
        }
    }
    public void m1() { //外部类---访问------>静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
    public Inner10 getInner10() {
        return new Inner10();
    }
    public static Inner10 getInner10_() {
        return new Inner10();
    }
}