java基础韩顺平老师的面向对象（高级）自己记的部分笔记

373，类变量引出

代码就提到了问题分析里的3点

package com.hspedu.static_;

public class ChildGame {
    public static void main(String[] args) {
        //定义一个变量 count，统计有多少小孩加入了游戏
        int count = 0;

        Child child1 = new Child("张三");
        child1.join();
        count++;

        Child child2 = new Child("李四");
        child2.join();
        count++;

        Child child3 = new Child("王五");
        child3.join();
        count++;

        System.out.println("共有" + count + " 小孩加入了游戏...");
    }
}
class Child{
    private String name;
    public Child(String name)
    {
        this.name = name;
    }
    public void join()
    {
        System.out.println(name + " 加入了游戏...");
    }
}

374，类变量快速入门

package com.hspedu.static_;

public class ChildGame {
    public static void main(String[] args) {
        //定义一个变量 count，统计有多少小孩加入了游戏
        int count = 0;

        Child child1 = new Child("张三");
        child1.join();
        //count++;
        child1.count++;

        Child child2 = new Child("李四");
        child2.join();
        //count++;
        child2.count++;

        Child child3 = new Child("王五");
        child3.join();
        //count++;
        child3.count++;

        System.out.println("共有" + Child.count + " 小孩加入了游戏...");
    }
}
class Child{
    private String name;
    //定义一个变量 count，是一个类变量（静态变量）static 静态
    //该变量最大的特点就是会被Child类的所有的对象实例共享
    public static int count = 0;
    public Child(String name)
    {
        this.name = name;
    }
    public void join()
    {
        System.out.println(name + " 加入了游戏...");
    }
}

运行结果：

记住：

static变量是对象共享，不管static变量在哪里，static变量是同一个类所有对象共享的；static类变量，在类加载的时候就生成了。

376，类变量定义访问

377，类变量使用细节

378，类方法快速入门

package com.hspedu.static_;

public class StaticMethod {
    public static void main(String[] args) {
        //创建2个学生对象，交学费
        Stu tom = new Stu("tom");
        tom.payFee(100);//Stu.payFee(100)也是对的

        Stu mary = new Stu("mary");
        Stu.payFee(200);

        //输出当前收到的总学费
        Stu.showFee();//300
    }
}
class Stu{
    private String name;//普通成员
    //定义一个静态变量，来累积学生的学费
    private static double fee = 0;

    public Stu(String name)
    {
        this.name = name;
    }
    //1,当方法使用了static修饰后，该方法就是静态方法
    //2,静态方法就可以访问到静态属性/变量
    public static void payFee(double fee)
    {
        Stu.fee += fee;
    }
    public static void showFee()
    {
        System.out.println("总学费有：" + Stu.fee);
    }
}

运行结果：

379，类方法最佳实践

package com.hspedu.static_;

public class StaticMethod {
    public static void main(String[] args) {
        System.out.println(MyTools.calSum(1,2));
    }
}
//开发自己的工具类，可以将方法做成静态的，方便调用
class MyTools{
    public static double calSum(double n1, double n2)
    {
        return n1 + n2;
    }
}

运行结果：

380，类方法注意事项

382，main语法说明（和 384 main动态传值）

在idea的 Edit configurations 也能设置String类型的数组参数

package com.hspedu.static_;

public class StaticMethod {
    public static void main(String[] args) {
        for(int i = 0; i < args.length; i++)
        {
            System.out.print(args[i] + " ");
        }
    }
}

代码运行结果：

383，main特别说明

package com.hspedu.static_;

public class Main01 {
    //静态的变量/属性
    private static String name = "韩顺平教育";
    //非静态的变量/属性
    private int n1 = 100;

    //静态方法
    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，静态方法可以访问本类的静态成员
        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();

    }
}

运行结果：

385，代码块快速入门

代码块调用的顺序优先于构造器

package com.hspedu.codeblock_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("你好，李焕英");
        System.out.println("==================");
        Movie movie1 = new Movie("唐探3", 100, "陈思成");
    }
}
class Movie{
    private String name;
    private double price;
    private String director;

    //构造器 ---> 重载
    //（1）下面的三个构造器都有相同的语句，就是3个输出语句本来在构造器里写着，现在放在{}里了
    //（2）这样代码看起来比较冗余
    //（3）这时我们可以把相同的语句，放入到一个代码块中，即可
    //（4）这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //（5）代码块调用的顺序优先于构造器...
    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }

    public Movie(String name) {
        System.out.println("Movie(String name) 被调用...");
        this.name = name;
    }

    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director) 被调用");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

运行结果：

386，代码块使用细节1

因为在类加载的时候，会调用代码块，所以当我们知道代码块啥时候调用时，就能知道类啥时候加载。

package com.hspedu.codeblock_;

public interface 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);//静态代码块一定会执行

    }
}
class DD {
    public static int n1 = 88;//静态属性
    //静态代码块
    static {
        System.out.println("DD 的静态代码1被执行...");
    }
    //普通代码块，在new 对象时，被调用，而且是每创建一个对象，就调用一次
    //可以这样简单的理解 普通代码块是构造器的补充，DD.n1就没有用到构造器
    {
        System.out.println("DD 的普通代码块...");
    }
}
class Cat {
    public static int n1 = 999;//静态属性
    //静态代码块
    static {
        System.out.println("Cat 的静态代码1被执行...");
    }
}
class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码1被执行...");
    }
}
class AA extends BB{ //BB的子类
    //静态代码块
    static {
        System.out.println("AA 的静态代码1被执行...");
    }
}

387，代码块使用细节2

package com.hspedu.codeblock_;

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

    }
}
class A{
    //普通属性的初始化
    private int n2 = getN2();
    //静态属性的初始化
    private static int n1 = getN1();

    //普通代码块
    {
        System.out.println("A 普通代码块01");
    }
    //静态代码块
    static {
        System.out.println("A 静态代码块01");
    }
    //静态方法
    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() 构造器被调用");
    }
}

运行结果：

388，代码块使用细节3

package com.hspedu.codeblock_;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB();//先看父类，再看子类，顺序和上节讲的一样
    }
}
class AAA{
    {
        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() 构造器被调用...");
    }
}

运行结果：

389，代码块使用细节4

package com.hspedu.codeblock_;

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //(1)进行类的加载
        //(2)创建对象
        new B02();//对象
    }
}
class A02{ //父类
    private static int n1 = getVal01();
    static {
        System.out.println("A02的一个静态代码块...");
    }
    {
        System.out.println("A02的一个普通代码块");
    }
    public int n3 = getVal02();
    public static int getVal01()
    {
        System.out.println("getVal01");
        return 10;
    }
    public int getVal02()
    {
        System.out.println("getVal02");
        return 10;
    }
    public A02()
    {
        System.out.println("A02的构造器");
    }
}
class B02 extends A02{
    private static int n3 = getVal03();
    static {
        System.out.println("B02的一个静态代码块...");
    }
    {
        System.out.println("B02的一个普通代码块");
    }
    public int n5 = getVal04();
    public static int getVal03()
    {
        System.out.println("getVal03");
        return 10;
    }
    public int getVal04()
    {
        System.out.println("getVal04");
        return 10;
    }
    public B02()
    {
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化
        System.out.println("B02的构造器");
    }
}

运行结果：

391，单例模式饿汉式

package com.hspedu.codeblock_;

public class SingleTon01 {
    public static void main(String[] args) {
        //通过方法可以获取对象
        GirlFriend instance = GirlFriend.getInstance();
        System.out.println(instance);

        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance2);

        System.out.println(instance == instance2); // true，static 只会初始化一次

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

    private static GirlFriend gf = new GirlFriend("小红红");//只要类加载，还没有用到gf，就已经创建好了一个对象，叫饿汉式
    //如何保障我们只能创建一个 GirlFriend 对象
    //步骤（单例模式-饿汉式）
    //1，将构造器私有化
    //2，在类的内部直接创建对象（该对象是static）
    //3，提供一个公共的static方法，返回 gf 对象
    private GirlFriend(String name)
    {
        this.name = name;
    }
    public static GirlFriend getInstance()
    {
        return gf;
    }

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

运行结果：

392，单例模式懒汉式

package com.hspedu.codeblock_;

public class SingleTon02 {
    public static void main(String[] args) {
        Cat instance = Cat.getInstance();
        System.out.println(instance);

        //再次调用getInstance
        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);
    }
}
//希望在程序运行过程中，只能创建一个Cat对象
//使用单例模式
class Cat {
    private String name;
    private static Cat cat = null;//默认是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 + '\'' +
                '}';
    }
}

运行结果：

393，final基本使用

package com.hspedu.final_;

public class Final01 {
    public static void main(String[] args) {
        E e = new E();
        //e.TAX_RATE = 0.09;
    }
}

//如果我们要求A类不能被其他类继承
//可以使用final修饰 A类
final class A {}
//calss B extends A{}

class C{
    //如果我们要求hi不能被子类重写
    //可以使用final修饰 hi 方法
    public final void hi() {}
}
class D extends C {
//    public void hi() {
//        System.out.println("重写了C类的hi方法...");
//    }
}

//当不希望类的某个属性的值被修改，可以用final修饰
class E {
    public final double TAX_RATE = 0.08;
}

//当不希望某个局部变量被修改，可以使用final修饰
class F {
    public void cry()
    {
        //这时，NUM也称为 局部变量
        final double NUM = 0.01;
        //NUM = 0.9;
        System.out.println("NUM = " + NUM);;
    }
}

394，final使用细节1

package com.hspedu.final_;

public class Final01 {
    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(double TAX_RATE2) { //构造器中赋值
        this.TAX_RATE2 = TAX_RATE2;
    }
    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }
}
class BB {
    /*
    如果final修饰的属性是静态的，则初始化的位置只能是
    1，定义时  2，在静态代码块 不能在构造器中赋值
    * */
    public static final double TAX_RATE = 9.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 { }

运行结果：

395，final使用细节2

package com.hspedu.final_;

public class Final01 {
    public static void main(String[] args) {
        System.out.println(BBB.num);
    }
}
//final 和 static 往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理
class BBB {
    public final static int num = 100;
    static {
        System.out.println("BBB 静态代码块被执行");
    }
}

运行结果：

397，抽象类引出

package com.hspedu.abstract_;

public class Abstract01 {
    public static void main(String[] args) {

    }
}
abstract class Animal {
    private String name;

    public Animal(String name)
    {
        this.name = name;
    }
    //思考：这里eat 这里你实现了，其实没有什么意义
    //即：父类方法不确定性的问题
    //----> 考虑将该方法设计为抽象(abstract)方法
    //----> 所谓抽象方法就是没有实现的方法
    //----> 所谓没有实现就是指，没有方法体
    //----> 当一个类中存在抽象方法时，需要将该类声明为abstract类
    //----> 一般来说，抽象类会被继承，有其子类来实现抽象方法
//    public void eat(){
//        System.out.println("这是一个动物，但是不知道吃什么...");
//    }
    public abstract void eat();
}

398，抽象类细节1

package com.hspedu.abstract_;

public class Abstract01 {
    public static void main(String[] args) {

    }
}
//抽象类不一定要包含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;
}

399，抽象类细节2

package com.hspedu.abstract_;

public class Abstract01 {
    public static void main(String[] args) {

    }
}
abstract class H {
    public abstract void hi();
}
//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E{
    public abstract void hi();//抽象方法，static 无法被重写
}
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");
    }
}

401，抽象模板模式

父类模板类 Tmeplate 代码

package com.hspedu.abstract_;

abstract public class Template { //抽象类-模块设计模式
    public abstract void job();//抽象方法
    public void calculateTime(){//实现方法，调用job方法
        long start = System.currentTimeMillis();//得到开始的时间
        job();//动态绑定机制
        long end = System.currentTimeMillis();//得到结束的时间
        System.out.println("任务执行时间 " + (end - start));
    }
}

子类AA类代码

package com.hspedu.abstract_;

public class AA extends Template{
    //计算任务
    //1+...+80000
    @Override
    public void job() {//实现Template的抽象方法job
        long num = 0;
        for (long i = 1; i <= 80000; i++) { //快捷键 80000.for 回车
            num += i;
        }
    }
}

子类BB类代码

package com.hspedu.abstract_;

public class BB extends Template{
    @Override
    public void job() {//这里也去重写了Template的job方法
        long num = 0;
        for (long i = 1; i <= 80000; i++) {
            num *= i;
        }
    }
}

主类TestTemplate代码

package com.hspedu.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();

        BB bb = new BB();
        bb.calculateTime();
    }
}

运行结果：

402，接口快速入门

接口 UsbInterface类方法

package com.hspedu.interface_;

public interface UsbInterface {//接口
    //规定接口的相关方法
    public void start();
    public void stop();
}

Phone类代码

package com.hspedu.interface_;

//Phone类实现UsbInterface
//解读1，即 Phone类需要实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface{
    @Override
    public void start() {
        System.out.println("手机开始工作...");
    }

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

Camera类代码

package com.hspedu.interface_;

public class Camera implements UsbInterface{//实现接口

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

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

Computer类代码

package com.hspedu.interface_;

public class Computer {
    //编写一个方法，计算机工作
    //1，UsbInterface usbInterface 形参是接口类型 UsbInterface
   //2，看到 接收 实现了 UsbInterface接口的类的对象实例

    public void work(UsbInterface usbInterface)
    {
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

主类 Interface01类代码

package com.hspedu.interface_;

public class Interface01 {
    public static void main(String[] args) {
        //创建相机，手机对象
        Camera camera = new Camera();
        Phone phone = new Phone();
        //创建计算机
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到计算机
        System.out.println("===============");
        computer.work(camera);//把相机接入到计算机
    }
}

运行结果：

403，接口基本介绍

如下接口：

package com.hspedu.interface_;

public interface AInterface {
    //写属性
    public int n1 = 10;
    //写方法
    //在接口中，抽象方法，可以省略abstract关键字
    public void hi();
    //在jdk8后，可以有默认实现方法，需要使用default关键字修饰
    default public void ok() {
        System.out.println("ok...");
    }
    //在jdk8后，可以有静态方法
    public static void cry() {
        System.out.println("cry...");
    }
}

404，接口应用场景

接口 DBInterface类代码

package com.hspedu.interface_;

public interface DBInterface {//项目经理
    public void connect();//连接方法
    public void close();//关闭连接
}

MysqlDB类代码

package com.hspedu.interface_;
//A程序员连接Mysql
public class MysqlDB implements DBInterface{
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql");
    }
}

Oracle类代码

package com.hspedu.interface_;
//B程序员连接Oracle
public class OracleDB implements DBInterface{
    @Override
    public void connect() {
        System.out.println("连接oracle");
    }

    @Override
    public void close() {
        System.out.println("关闭oracle");
    }
}

主类 Interface03类代码

package com.hspedu.interface_;

public class Interface03 {
    public static void main(String[] args) {
        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);   //主方法是static，可以调用static的t方法
        System.out.println("=====================");
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }
    public static void t(DBInterface dbInterface)
    {
        dbInterface.connect();
        dbInterface.close();
    }
}

运行结果：

405，接口使用细节1

package com.hspedu.interface_;

public class InterfaceDetail01 {
    public static void main(String[] args) {
       //new IA();
    }
}
//1，接口不能被实例化
//2，接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
//3，一个普通类实现接口，就必须将该接口的所有方法都实现
//4，抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//不写修饰符，其实是public
}
class Cat implements IA{ //快捷键 alt + enter 可以快速添加实现方法

    @Override
    public void say() {

    }
}
abstract class Tiger implements IA {

}

406，接口使用细节2

package com.hspedu.interface_;

public class InterfaceDetail02 {
    public static void main(String[] args) {
        System.out.println(IB.n1);//说明 n1 就是 static
        //IB.n1 = 30;//说明n1是final
    }
}
//接口的修饰符只能是public和默认，这点和类的修饰符是一样的
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 {
}
//一个类同时可以实现多个接口
class Pig implements IB,IC {

    @Override
    public void hi() {
    }

    @Override
    public void say() {
    }
}

408，接口VS继承

解耦即：接口规范性+动态绑定

package com.hspedu.interface_;

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}
//猴子
class Monkey {
    private String name;

    public Monkey(String name) {
        this.name = name;
    }

    public void climbing(){
        System.out.println(name +" 会爬树...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}
//继承
//小结： 当子类继承了父类，就自动的拥有了父类的功能
//      如果子类需要扩展功能，可以通过实现接口的方式扩展
//      可以理解 实现接口 是 对java 单继承机制的一种补充
class LittleMonkey extends Monkey implements Fishable,Birdable {

    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
    }

    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

运行结果：

409，接口多态特性

案例1：多态参数

package com.hspedu.interface_;

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();
        
        //继承体现的多态
        //父类类型的变量 a 可以指向 继承AAA的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}
interface IF {}
class Monster implements IF{}
class Car implements IF{}

class AAA {
    
}
class BBB extends AAA{}
class CCC extends AAA{}

案例2：多态数组

package com.hspedu.interface_;

public class InterfacePloyArr {
    public static void main(String[] args) {
        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();

        for(int i = 0; i < usbs.length; i++)
        {
            usbs[i].work();//动态绑定
            //需要进行类型的向下转型
            if(usbs[i] instanceof Phone_)//判断他的运行类型是 Phone_
            {
                ((Phone_) usbs[i]).call();//调用Phone_的特有方法call
            }
        }
    }
}
interface Usb{
    void work();
}
class Phone_ implements Usb {
    public void call(){
        System.out.println("手机可以打电话...");
    }
    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}
class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}

运行结果：

案例3：多态传递

package com.hspedu.interface_;

public class InterfacePloyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果Teacher 类实现了 IG 接口,IG 继承了IH 接口
        //那么，实际上就相当于 Teacher 类也实现了 IH 接口
        //这就是所谓的 接口多态传递现象
        IH ih = new Teacher();
    }
}
interface IH { }
interface IG extends IH{ }
class Teacher implements IG {

}

412，四种内部类

package com.hspedu.InnerClass;

public class InnerClasses01 {//外部其他类
    public static void main(String[] args) {

    }
}
class Outer {//外部类
    private int n1 = 100;//属性
    public Outer(int n1) {//构造器
        this.n1 = n1;
    }
    public void m1() {//方法
        System.out.println("m1()");
    }
    {//代码块
        System.out.println("代码块...");
    }
    class Inner {//内部类，在Outer类的内部

    }
}

413，局部内部类1

package com.hspedu.InnerClass;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}
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,可以直接访问外部类的所有成员，包含私有的
            public void f1() {
                //5,局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
                System.out.println("n1=" + n1);
                m2();
            }
        }
        //6,外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

运行结果：

414，局部内部类2

package com.hspedu.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();
    }
}

运行结果：

415，匿名内部类本质（和 416 匿名内部类使用）

没有名字只是隐藏了，看不到而已。

1，演示基于接口，类，抽象类的匿名内部类

package com.hspedu.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的运行类型？就是匿名内部类 XXXX -> Outer04$1
        /*
        * 我们看底层 会分配 类名 Outer04$1
        * class Outer04$1 implements IA {
              @Override
              public void cry() {
                  System.out.println("老虎叫唤...");
              }
        }
        * */
        //7，jdk底层在创建匿名内部类 Outer04$1,立即马上创建了 Outer04$1实例，并且把地址
        //   返回给tiger
        //8，匿名内部类使用一次，就不能再使用，但是下面实例的对象tiger可以反复使用
        IA tiger = new IA() {

            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();
//        IA tiger = new Tiger();
//        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 Tiger implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("老虎叫唤...");
//    }
//}
//class Dog implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("小狗汪汪...");
//    }
//}

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

    }
}

abstract class Animal {//抽象类
    abstract void eat();
}

运行结果：

417，匿名内部类细节

package com.hspedu.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");

    }
}

abstract class Person {//类

    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok(String str) {
        System.out.println("Person ok() " + str);
    }

}

//抽象类/接口

运行结果：

418，匿名内部类实践

1，练习1，当做实参直接传递

package com.hspedu.InnerClass;

public class InnerClassExercise01 {
    public static void main(String[] args) {

        //当做实参直接传递，简洁高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一幅名画~...");
            }
        });
        //传统方法
        f1(new Picture());
    }

    //静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}
//接口
interface IL {
    void show();
}
//类 -> 实现IL => (硬编码)
class Picture implements IL {

    @Override
    public void show() {
        System.out.println("这是一幅名画xx...");
    }
}

运行结果：

2，练习2

package com.hspedu.InnerClass;

public class InnerClassExercise02 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        //1，传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1
        //2，重写了 ring
        //3，Bell bell = new Bell() {
        //            @Override
        //            public void ring() {
        //                System.out.println("懒猪起床了");
        //            }
        //        };

        cellPhone.alarmclock(new Bell() {

            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        cellPhone.alarmclock(new Bell() {

            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });

    }
}
interface Bell {//接口
    void ring();//方法
}
class CellPhone {//类
    public void alarmclock(Bell bell)//形参是Bell接口类型
    {
        System.out.println(bell.getClass());
        bell.ring();//动态绑定
    }
}

运行结果：

419，成员内部类1

package com.hspedu.InnerClass;

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
    }
}
class Outer08 {//外部类
    private int n1 = 10;
    public String name = "张三";

    //1，注意：成员内部类，是定义在外部类的成员位置上
    //2，可以添加任意访问修饰符(public,protected,默认,private),因为它的地位就是一个成员
    private class Inner08 {//成员内部类
        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            System.out.println("n1 = " + n1 + " name = " + name);
        }
    }

    //写方法
    public void t1() {
        //使用成员内部类
        Inner08 inner08 = new Inner08();
        inner08.say();
    }
}

运行结果：

420，成员内部类2

package com.hspedu.InnerClass;

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其他类，使用成员内部类的两种方式
        //其他外部类访问内部类，方式1
        //老韩解读
        //outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员
        //这就是一个语法，不要特别的纠结
        Outer08.Inner08 inner08 = outer08.new Inner08();

        //第二种方式，在外部类中，编写一个方法，可以返回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),因为它的地位就是一个成员
    class Inner08 {//成员内部类
        public 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);
    }
}

运行结果：

421，静态内部类

package com.hspedu.InnerClass;

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();

        //外部其他类 使用静态内部类
        //方式1
        //因为静态内部类，是可以通过类名直接访问（前提是满足访问权限）
        Outer10.Inner10 inner10 = new Outer10.Inner10();//类名访问是指 new那里用了  外部类名.静态内部类名，不用创建对象了
        inner10.say();

        //方式二
        //编写一个方法，可以返回静态内部类的对象实例
        Outer10.Inner10 inner101 = Outer10.getInner10();//静态可以通过类名访问
        System.out.println("==================");
        inner101.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);
        }
    }

    public void m1() {//外部类---访问------>静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public static Inner10 getInner10() {
        return new Inner10();
    }
}

运行结果：

436，家庭作业1

package com.hspedu.enum_;

public class Homework {
    public static void main(String[] args) {

    }
}
class Frock{
    private static int currentNum = 100000;
    private int serialNumber;

    public static int getNextNum()
    {
        currentNum += 100; //将currentNum增加100
        return currentNum;
    }

    public Frock() {
        serialNumber = getNextNum();
    }

    public int getSerialNumber() {
        return serialNumber;
    }

}
class TestFrock{
    public static void main(String[] args) {
        System.out.println(Frock.getNextNum());//100100
        System.out.println(Frock.getNextNum());//100200
        Frock frock = new Frock();//序列号就是100300
        Frock frock1 = new Frock();//序列号就是100400
        Frock frock2 = new Frock();//序列号就是100500
        System.out.println(frock.getSerialNumber());//100300
        System.out.println(frock1.getSerialNumber());//100400
        System.out.println(frock2.getSerialNumber());//100500
    }
}

437，家庭作业2（匿名内部类的题）

package com.hspedu.enum_;

public class Homework {
    public static void main(String[] args) {
        Celllphone celllphone = new Celllphone();
        //老韩解读
        //1，匿名内部类是
        /*
        new ICalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1 + n2;
            }
        }, 同时也是一个对象
         他的编译类型 ICalculate，他的运行类型就是 匿名内部类
         */
        celllphone.testWork(new ICalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1 + n2;
            }
        }, 10, 8);//18

        celllphone.testWork(new ICalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1 * n2;
            }
        }, 10, 8);//80
    }
}
interface ICalculate{
    //work方法 是完成计算，但是题没有具体要求，所以自己设计
    //至于该方法完成怎样的计算，我们交给匿名内部类完成
    public double work(double n1, double n2);
}
class Celllphone {
    //老韩解读，当我们调用testWork方法时，直接传入一个实现了ICalculate接口的匿名内部类即可
    //该匿名内部类，可以灵活的实现work，完成不同的计算任务
    public void testWork(ICalculate iCalculate, double n1, double n2)
    {
        double result = iCalculate.work(n1, n2);//动态绑定
        System.out.println("计算后的结果是= " + result);
    }
}

438，家庭作业3（局部内部类的题）

package com.hspedu.enum_;

public class Homework {
    public static void main(String[] args) {
        new A().f1();
    }
}
class A { //外部类
    private String NAME = "hello";
    public void f1() {
        class B {//局部内部类
            private final String NAME = "韩顺平教育";
            public void show()
            {
                //如果内部类和外部类的属性重名，可以同 外部类.this.属性名来指定
                System.out.println("NAME=" + NAME + " 外部类的name=" + A.this.NAME);
            }
        }
        //别忘了：外部类A类在方法中，可以创建B类对象，然后调用方法即可
        B b = new B();
        b.show();
    }
}

439，家庭作业4（综合题）

编程：需求 -----> 理解-------> 代码 ---------> 优化

增加一个情况，如果唐僧过火焰山，使用飞机 ----> 程序扩展性，我们前面的程序结构就非常好扩展

文件结构如下：

Vehicles接口类代码：

package com.hspedu.homework;

public interface Vehicles {
    //有一个交通工具接口类Vehicles，有work接口
    public void work();
}

Boat类代码：

package com.hspedu.homework;

public class Boat implements Vehicles{
    @Override
    public void work() {
        System.out.println("过河的时候，使用小船...");
    }
}

Horse类代码：

package com.hspedu.homework;

public class Horse implements Vehicles{
    @Override
    public void work() {
        System.out.println("一般情况下，使用马儿前进...");
    }
}

Plane类代码：

package com.hspedu.homework;

public class Plane implements Vehicles{
    @Override
    public void work() {
        System.out.println("过火焰山，使用飞机...");
    }
}

VehiclesFactory类代码：

package com.hspedu.homework;

public class VehiclesFactory {
    //马儿始终是同一匹，因为唐僧西天取经只骑着同一匹白龙马
    private static Horse horse = new Horse();//饿汉式

    private VehiclesFactory(){}
    //创建交通工厂类，有两个方法分别获得交通工具Horse和Boat
    //用static是因为，我们只用VehiclesFactory类里的方法，不用创建对象了
    public static Horse getHorse(){
//        return new Horse();
          return horse;
    }
    public static Boat getBoat(){
        return new Boat();
    }
    public static Plane getPlane(){
        return new Plane();
    }
}

Person类代码：

package com.hspedu.homework;

public class Person {
    private String name;
    private Vehicles vehicles;

    //在创建人对象时，事先给他分配一个交通工具
    public Person(String name, Vehicles vehicles) {
        this.name = name;
        this.vehicles = vehicles;
    }
    //思考一个问题，如何不浪费，在构建对象时，传入的交通工具对象
    public void passRiver(){
        //先得到船
        //判断一下，当前的 vehicles 属性是null，就获取一艘船
//        Boat boat = VehiclesFactory.getBoat();
//        boat.work();
        //如何防止始终使用的是传入的马 instanceof
        // vehicles instanceof Boat 是判断 当前的 vehicles是不是Boat
        //(1) vehicles = null : vehicles instanceof Boat => false
        //(2) vehicles = 马对象 : vehicles instanceof Boat => false
        //(3) vehicles = 船对象 : vehicles instanceof Boat => true
        if(!(vehicles instanceof Boat))
        {
            //这里使用的是多态
            vehicles = VehiclesFactory.getBoat();
        }
        vehicles.work();
    }
    public void common(){
        //得到马儿
        //判断一下，当前的 vehicles 属性是null，就获取一匹马
        if(!(vehicles instanceof Horse) )
        {
            //这里使用的是多态
            vehicles = VehiclesFactory.getHorse();
        }
        //这里体现使用接口调用
        vehicles.work();
    }
    //过火焰山
    public void passFireHill(){
        //得到马儿
        //判断一下，当前的 vehicles 属性是null，就获取一匹马
        if(!(vehicles instanceof Plane) )
        {
            //这里使用的是多态
            vehicles = VehiclesFactory.getPlane();
        }
        //这里体现使用接口调用
        vehicles.work();
    }
}

Homework1主类代码：

package com.hspedu.homework;

public class Homework1 {
    public static void main(String[] args) {
        Person tang = new Person("唐僧", new Horse());
        tang.common();//一般情况下
        tang.passRiver();//过河
        tang.common();//一般情况下
        tang.passRiver();//过河
        tang.passRiver();//过河
        //过火焰山
        tang.passFireHill();
    }
}

主类运行结果：

440，家庭作业5（成员内部类的题）

package com.hspedu.enum_;

public class Homework {
    public static void main(String[] args) {
        //实例化不同的car对象
        Car car = new Car(60);
        car.getAir().flow();
        Car car1 = new Car(-1);
        car1.getAir().flow();
        Car car2 = new Car(20);
        car2.getAir().flow();
    }
}
class Car {
    private double temperature;

    public Car(double temperature) {
        this.temperature = temperature;
    }

    //Air 成员内部类
    class Air {
        public void flow() {
            if(temperature > 40)
            {
                System.out.println("温度大于40 空调吹冷气...");
            } else if(temperature < 0)
            {
                System.out.println("温度小于0 空调吹暖气...");
            } else {
                System.out.println("温度正常，关闭空调...");
            }
        }
    }
    //返回一个Air对象
    public Air getAir()
    {
        return new Air();
    }
}

posted @ 2024-03-27 22:26 银河小船儿阅读(21) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

romantichuaner

java基础 韩顺平老师的 面向对象（高级） 自己记的部分笔记

373，类变量引出

374，类变量快速入门

记住：

376，类变量定义访问

377，类变量使用细节

378，类方法快速入门

379，类方法最佳实践

380，类方法注意事项

382，main语法说明（和 384 main动态传值 ）

383，main特别说明

385，代码块快速入门

386，代码块使用细节1

387，代码块使用细节2

388，代码块使用细节3

389，代码块使用细节4

391，单例模式饿汉式

392，单例模式懒汉式

393，final基本使用

394，final使用细节1

395，final使用细节2

397，抽象类引出

398，抽象类细节1

399，抽象类细节2

401，抽象模板模式

402，接口快速入门

403，接口基本介绍

404，接口应用场景

405，接口使用细节1

406，接口使用细节2

408，接口VS继承

409，接口多态特性

案例1：多态参数

案例2：多态数组

案例3：多态传递

412，四种内部类

413，局部内部类1

414，局部内部类2

415，匿名内部类本质 （和 416 匿名内部类使用）

1，演示基于接口，类，抽象类的匿名内部类

417，匿名内部类细节

418，匿名内部类实践

1，练习1，当做实参直接传递

2，练习2

419，成员内部类1

420，成员内部类2

421，静态内部类

436，家庭作业1

437，家庭作业2（匿名内部类的题）

438，家庭作业3（局部内部类的题）

439，家庭作业4（综合题）

文件结构如下：

440，家庭作业5（成员内部类的题）

公告

java基础韩顺平老师的面向对象（高级）自己记的部分笔记

382，main语法说明（和 384 main动态传值）

415，匿名内部类本质（和 416 匿名内部类使用）