java进阶教程：2023.3.9第十一天，java进阶加强面向对象高级

前言

记录时间：2023.3.9

已坚持的第十一天

java从入门到精通

学习java时间历程记录打卡

早上6：00到 12：00

下午1：00到7:30

java面向高级对象进阶总结

完成代码练习

1.d1_package

1.学会导包

package cn.vqqc.d1_package.it;

public class Student {
}

package cn.vqqc.d1_package.it2;

public class Student {
}

package cn.vqqc.d1_package;

//导包
import cn.vqqc.d1_package.it.Student;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //目标：理解一下两点
        //1.同一个包下的类，互相可以直接访问
        System.out.println(User.onlineNumber);
        //2.不同的包的类，必须先导包才可以访问
        Student s = new Student();
        Scanner sc= new Scanner(System.in);

        //3.如果这个类中使用不同包下的相同的类名，此时默认只能导入一个类的包，另外一个类使用全名访问
        cn.vqqc.d1_package.it2.Student s2 = new cn.vqqc.d1_package.it2.Student();


    }
}

package cn.vqqc.d1_package;

public class User {
    public static int onlineNumber = 121;

}

2.d2_modifier

1.理解权限修饰符的修饰范围

package cn.vqqc.d2_modifier.itcast;

import cn.vqqc.d2_modifier.Fu;

public class Test2 {
    public static void main(String[] args) {
        Fu f = new Fu();
       // f.privateMethod(); //报错
       // f.method();//报错
       // f.protectedMethod();//报错
        f.publicMethod();
    }
}

package cn.vqqc.d2_modifier.itcast;

import cn.vqqc.d2_modifier.Fu;

public class Zi extends Fu {
    public static void main(String[] args) {
        Zi  zi = new Zi();
        zi.protectedMethod();
        zi.publicMethod();

        Fu f = new Fu();
        f.publicMethod();
    }
}

package cn.vqqc.d2_modifier;

public class Fu {
    /*
        1.定义私有的成员: private 只能本类中访问
     */
    private void privateMethod(){
        System.out.println("private");
    }
    /*
       2.定义缺省修饰的成员: private 只能本类中，同包下其他类访问(包访问权限)
    */
     void method(){
        System.out.println("缺省");
    }

    /*
        3.protected修饰的方法：本类同包的其他类中，其他包的子类中
     */
    protected void protectedMethod(){
        System.out.println("protected");
    }


    /*
        3.protected修饰的方法：本类同包的其他类中，其他包的子类中,其他包的无关类中
     */
    public void publicMethod(){
        System.out.println("public");
    }

    public static void main(String[] args) {
        Fu f = new Fu();
        f.privateMethod();
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }
}

package cn.vqqc.d2_modifier;

public class Test {
    public static void main(String[] args) {
        //目标；讲解权限修饰符的修饰范围，明白一种修饰后的作用范围
        Fu f = new Fu();
       // f.privateMethod(); //报错，私有的
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }

}

3.d3_final

1.final的语法

package cn.vqqc.d3_final;

public class Test {
    public static void main(String[] args) {
        // 目标：记住final的语法
        // 1、final修饰类，类不能被继承
        // 2、final修饰方法，方法不能被重写
        // 3、final修饰变量，总规则：变量有且仅能被赋值一次
    }
}

class Student extends People{
//    @Override
//    public void eat() {
//        System.out.println("学生吃的很多");
//    }
}

class People{
    public final void eat(){
        System.out.println("人都要吃东西");
    }
}


//class Wolf extends Animal{
//}
//
//final class Animal{
//}

2.理解final修饰变量的作用

package cn.vqqc.d3_final;

public class Test2 {

    /**
     二：修饰静态成员变量(public static final修饰的也称为常量了)
     */
    public static final String schoolName = "try";

    /**
     三，修饰实例成员变量。（几乎不用）
     */
    private final String name = "try栈";

    public static void main(String[] args) {
        // 目标：理解final修饰变量的作用：总规则：变量有且仅能被赋值一次。（理解语法）
        // 变量有几种：
        //    1、局部变量
        //    2、成员变量
        //           /实例成员变量
        //           /静态成员变量

        // 一：修饰局部变量
        final double rate = 3.14;
        // rate = 3.19; // 第二次赋值了
        buy(0.8);

        // schoolName = "try栈"; // 第二次赋值了

        Test2 t = new Test2();
        System.out.println(t.name);
        // t.name = "try栈";

        // 注意：final修饰引用类型的变量，其地址值不能改变，但是指向的对象的内容可以改变的。
        final Teacher t2 = new Teacher("学习，睡觉，打卡");
        // t2 = null;  // 第二次赋值了。
        System.out.println(t2.getHobby());
        t2.setHobby("运动");
        System.out.println(t2.getHobby());
    }

    public static void buy(final double z){
        // z = 0.1; // 第二次赋值了
    }
}

class Teacher{
    private String hobby;

    public Teacher(String hobby) {
        this.hobby = hobby;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

4.d4_constant

1.认识常量，知道常量的作用

package cn.vqqc.d4_constant;

/**
 常量类：配置类
 */
public class Constant {
    public static final int UP = 1;
    public static final int DOWN = 2;
    public static final int LEFT = 3;
    public static final int RIGHT = 4;
}

package cn.vqqc.d4_constant;

public class Test {
    /**
     常量：public static final修饰的成员变量，注意：名称全部英文大写，多个单词下划线连接
     */
    public static final String SCHOOL_NAME = "try栈";
    public static final String COUNTRY = "中国";
    public static final int NUMBER = 10000;

    // 常量：充当配置信息
    public static final String SCHOOL = "try栈";
    public static final String LOGIN_NAME = "admin";
    public static final String PASS_WORD = "123456";

    public static void main(String[] args) {
        // 目标：认识常量，知道常量的作用
        // SCHOOL_NAME = "try栈"; // 第二次赋值

        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
        System.out.println(SCHOOL);
    }
}

package cn.vqqc.d4_constant;


import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Test2 {


    public static void main(String[] args) {
        // 目标：理解常量的另外一个作用：做信息的标志和分类
        // 模拟：控制玛丽的移动：上下左右
        // 桌面编程
        // 1、创建窗口
        JFrame win = new JFrame("超级玛丽");
        win.setSize(300, 200);

        // 2、设计一个面板（桌布）
        JPanel jPanel = new JPanel();
        win.add(jPanel);

        // 2、放置几个按钮
        JButton b1 = new JButton("上");
        jPanel.add(b1);
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往上跳
                move(Constant.UP);
            }
        });

        JButton b2 = new JButton("下");
        jPanel.add(b2);
        b2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往下蹲
                move(Constant.DOWN);
            }
        });

        JButton b3 = new JButton("左");
        jPanel.add(b3);
        b3.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往左走
                move(Constant.LEFT);
            }
        });

        JButton b4 = new JButton("右");
        jPanel.add(b4);
        b4.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往右走
                move(Constant.RIGHT);
            }
        });

        win.setLocationRelativeTo(null);
        win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        win.setVisible(true);
    }

    public static void move(int orientation){
        // 控制玛丽移动
        switch (orientation) {
            case Constant.UP:
                System.out.println("玛丽往↑飞了一下");
                break;
            case Constant.DOWN:
                System.out.println("玛丽往↓蹲了一下");
                break;
            case Constant.LEFT:
                System.out.println("玛丽往←跑了一下");
                break;
            case Constant.RIGHT:
                System.out.println("玛丽往→跑了一下");
                break;
        }
    }
}

5.d5_enum

1.理解枚举

package cn.vqqc.d5_enum;

public enum Constant {
    UP,DOWN,LEFT,RIGHT;
}

package cn.vqqc.d5_enum;

public enum Season {
    // 第一行罗列枚举的实例：对象的名称
    SPRING,SUMMER,AUTUMN, WINTER;
}

package cn.vqqc.d5_enum;


public class Test {
    public static void main(String[] args) {
        // 目标：认识枚举
        Season s1 = Season.SPRING;
        System.out.println(s1);
    }
}

package cn.vqqc.d5_enum;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Test2 {


    public static void main(String[] args) {
        // 目标：使用枚举做信息标志和分类（最好的方案）
        // 1、创建窗口
        JFrame win = new JFrame("超级玛丽");
        win.setSize(300, 200);

        // 2、设计一个面板（桌布）
        JPanel jPanel = new JPanel();
        win.add(jPanel);

        // 2、放置几个按钮
        JButton b1 = new JButton("上");
        jPanel.add(b1);
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往上跳
                move(Constant.UP);
            }
        });

        JButton b2 = new JButton("下");
        jPanel.add(b2);
        b2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往下蹲
                move(Constant.DOWN);
            }
        });

        JButton b3 = new JButton("左");
        jPanel.add(b3);
        b3.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往左走
                move(Constant.LEFT);
            }
        });

        JButton b4 = new JButton("右");
        jPanel.add(b4);
        b4.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 控制玛丽往右走
                move(Constant.RIGHT);
            }
        });

        win.setLocationRelativeTo(null);
        win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        win.setVisible(true);
    }

    public static void move(Constant orientation){
        // 控制玛丽移动
        switch (orientation) {
            case UP:
                System.out.println("玛丽往↑飞了一下");
                break;
            case DOWN:
                System.out.println("玛丽往↓蹲了一下");
                break;
            case LEFT:
                System.out.println("玛丽往←跑了一下");
                break;
            case RIGHT:
                System.out.println("玛丽往→跑了一下");
                break;
        }
    }
}

6.d6_abstract

1.抽象类：有abstract修饰

package cn.vqqc.d6_abstract;

/**
 抽象类：有abstract修饰
 */
public abstract class Animal {
    private String name;
    /**
     抽象方法：有abstract修饰 不能写方法体代码
     */
    public abstract void run();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package cn.vqqc.d6_abstract;

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑的贼快");
    }
}

package cn.vqqc.d6_abstract;

public class Test {
    public static void main(String[] args) {
        // 目标：先认识抽象类，再了解它的使用场景
        Dog d = new Dog();
        d.run();
    }
}

7.d7_abstract_test

1.抽象类卡片支付案例

package cn.vqqc.d7_abstract_test;

public abstract class Card {
    private String userName;
    private double money;

    /**
     定义一个支付方法：表示卡片可以支付
     抽象方法
     */
    public abstract void pay(double money2);

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

package cn.vqqc.d7_abstract_test;

public class GoldCard extends Card{
    @Override
    public void pay(double money2) {
        System.out.println("您当前消费：" + money2);
        System.out.println("您卡片当前余额是：" + getMoney());
        // 优惠价：
        double rs = money2 * 0.8;
        System.out.println(getUserName() + ":您实际支付：" + rs);
        // 更新账户余额
        setMoney(getMoney() - rs);
    }
}

package cn.vqqc.d7_abstract_test;

public class Test {
    public static void main(String[] args) {
        // 目标：学习一下抽象类的基本使用：做父类，被继承，重写抽象方法
        GoldCard c = new GoldCard();
        c.setMoney(10000);
        c.setUserName("try");

        c.pay(300);
        System.out.println("剩余：" + c.getMoney());
    }
}

8.d8_abstract_attention

1.理解抽象类的特征和注意事项

package cn.vqqc.d8_abstract_attention;

public class Test {
    public static void main(String[] args) {
        // 目标：理解抽象类的特征和注意事项
        // 1、类有的东西，抽象类都有
        // 2、抽象类中可以没有抽象方法，但是有抽象方法的必须是抽象类。
        // 3、一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类

        // 4、抽象类不能创建对象 ，为什么？？

        // 反证法：假如抽象类可以创建对象。
        // Animal a = new Animal();
        // a.run(); // run方法连方法体都没有！ 因此抽象类不能创建对象

        // Card c = new Card(); // 不行的，抽象类不能创建对象（这个观点不能动摇）
    }
}

abstract  class Card{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

abstract class Cat extends Animal{
    @Override
    public void run() {
    }
}

abstract class Animal{
    public abstract void run();
    public abstract void eat();
}

9.d9_abstract_template

1.抽象类的模板

package cn.vqqc.d9_abstract_template;

public abstract class Student {
    /**
     正式：声明了模板方法模式
     final ：这个方法不能被子类重写，因为它是给子类直接使用的
     */
    public final void write(){
        System.out.println("\t\t\t\t《我的爸爸》");
        System.out.println("你的爸爸是啥样，来说说：");
        // 正文部分（每个子类都要写的，每个子类写的情况不一样
        //  因此。模板方法把正文部分定义成抽象方法，交给
        //  具体的子类来完成）
        System.out.println(writeMain());

        System.out.println("我的爸爸简直太好了");
    }

    public abstract String writeMain();
}

package cn.vqqc.d9_abstract_template;

public class StudentChild extends Student{
    @Override
    public String writeMain() {
        return "的爸爸太牛了，他总是买东西给我吃";
    }
}

package cn.vqqc.d9_abstract_template;

public class StudentMiddle extends Student{
    @Override
    public String writeMain() {
        return  "我的爸爸也很牛，我开车都不看红绿灯的，" +
                "下辈子还要做他儿子";
    }
}

package cn.vqqc.d9_abstract_template;

public class Test {
    public static void main(String[] args) {
        // 目标：理解模板方法模式的思想和使用步骤
        StudentMiddle s = new StudentMiddle();
        s.write();

        StudentChild s2 = new StudentChild();
        s2.write();
    }
}

10.d10_interface

1.认识接口中的成分特点：抽象方法和常量

package cn.vqqc.d10_interface;

/**
 声明了一个接口: 体现一种规范，规范一定是公开的
 */
public interface InterfaceDemo {
    // 目标：接口中的成分特点：JDK 8之前接口中只能有抽象方法和常量
    // 1、常量：
    // 注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public static final 可以省略不写
    String SHCOOL_NAME = "try";
    //public static final String SHCOOL_NAME = "try";

    // 2、抽象方法
    // 注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract可以省略不写
    void run();
    // public abstract void run();

    void eat();
    // public abstract void eat();
}

11.d11_interface_implements

1.理解接口的基本使用：被类实现

package cn.vqqc.d11_interface_implements;

public interface Law {
    void rule();// 遵纪守法
}

package cn.vqqc.d11_interface_implements;
/**
 实现类
 */
public class PingPongMan implements SportMan, Law{
    private String name;
    public PingPongMan(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name + "必须跑步训练！");
    }

    @Override
    public void competition() {
        System.out.println(name + "要参加比赛，为国争光！");
    }

    @Override
    public void rule() {
        System.out.println(name + "必须守法");
    }
}

package cn.vqqc.d11_interface_implements;

/**
 规范
 */
public interface SportMan {
    void run();
    void competition();
}

package cn.vqqc.d11_interface_implements;

public class Test {
    public static void main(String[] args) {
        // 目标：理解接口的基本使用：被类实现
        PingPongMan p = new PingPongMan("张继科");
        p.run();
        p.competition();
        p.rule();
    }
}

12.d12_interface_extends

1.理解接口多继承的作用

package cn.vqqc.d12_interface_extends;


/**
 一个实现类的：
 */
public class BasketBallMan implements SportMan{


    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

package cn.vqqc.d12_interface_extends;

public interface Law {
    void rule();
}

package cn.vqqc.d12_interface_extends;

public interface People {
    void eat();
    void sleep();
}

package cn.vqqc.d12_interface_extends;

public interface SportMan extends Law, People {
    void run();
    void competition();
}

package cn.vqqc.d12_interface_extends;

public class Test {
    public static void main(String[] args) {
        // 目标：理解接口多继承的作用
    }
}

13.d13_interface_jdk8

1.理解JDK 8开始接口新增的方法

package cn.vqqc.d13_interface_jdk8;

public class PingPongMan implements SportMan{
}

package cn.vqqc.d13_interface_jdk8;

public interface SportMan {

    /**
     1、默认方法：其实就是实例方法
     -- 必须用default修饰，默认会自带public
     -- 必须用接口的实现类的对象来调用
     */
    default void run(){
        go();
        System.out.println("==跑的贼溜==");
    }

    /**
     2、静态方法
     -- 必须static修饰，默认会自带public
     -- 必须用接口名自己调用
     */
    static void inAddr(){
        System.out.println("try栈");
    }

    /**
     3、私有实例方法：
     -- 必须用private修饰
     -- 只能本接口中访问。
     -- 一般给接口中其他的默认方法或者私有实例方法使用的
     */
    private void go(){
        System.out.println("开始跑");
    }
}

package cn.vqqc.d13_interface_jdk8;

public class Test {
    public static void main(String[] args) {
        // 目标：理解JDK 8开始接口新增的方法
        PingPongMan p = new PingPongMan();
        p.run();

        SportMan.inAddr();


    }
}

14.d14_interface_attention

1.了解接口使用的注意事项

package cn.vqqc.d14_interface_attention;

public class Test {
    public static void main(String[] args) {
        // 目标：了解接口使用的注意事项
//        1、接口不能创建对象
        // A a = new A();

//        2、一个类实现多个接口，多个接口的规范不能冲突

//        3、一个类实现多个接口，多个接口中有同样的静态方法不冲突。(接口的静态方法只能接口自己调)
        A.test();
        B.test();
//        4、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的
        Zi zi = new Zi();
        zi.go();

//        5、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可
        Zi2 zi2 = new Zi2();
        zi2.sing();

//        6、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承

    }
}
//        6、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承
//interface K extends I, J{
//
//}
//interface I{
//    void run();
//}
//
//interface J{
//    String run();
//}



//    5、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可
class Zi2 implements GanDie1, GanDie2{
    @Override
    public void sing() {
        GanDie1.super.sing();
        GanDie2.super.sing();
        System.out.println("我唱给大家听了");
    }
}

interface GanDie1{
    default void sing(){
        System.out.println("干爹1让你唱小苹果");
    }
}

interface GanDie2{
    default void sing(){
        System.out.println("干爹2让你唱征服");
    }
}


// 4、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的
class Zi extends Fu implements GanDie{
    public void go(){
        GanDie.super.run(); // 找干爹要这个爸爸的run方法
    }
}
class Fu {
    public void run(){
        System.out.println("亲爹说赶紧跑路");
    }
}
interface GanDie{
    default void run(){
        System.out.println("干爹说留在我身边");
    }
}



/**
 接口是干爹
 */
class C implements A, B{
    @Override
    public void run() {
    }
}

interface B{
    void run();
    static void test(){
    }
}

interface A{
    void run();
    static void test(){
    }
}