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

前言

记录时间：2023.3.8

已坚持的第十天

java从入门到精通

学习java时间历程记录打卡

早上6：00到 12：00

下午1：00到7:30

java面向高级对象总结

完成代码练习

1.复习面向对象

1.定义类

package cn.vqqc;

public class Car {
    private String name;
    private double price;

    public Car(String name, double price){
        // this代表了当前对象
        this.name = name;
        this.price = price;
    }

    public void goWith(String name){
        System.out.println(this);
        // 谁调用这个方法，this就代表谁
        System.out.println(this.name +
                "正在和" + name + "比赛~");
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

2.类的私有

package cn.vqqc;

public class People {
    // 1、成员变量私有化（合理隐藏）
    // private修饰的东西只能在本类中访问，其他类中不能访问
    private int age;

    // 2、提供公开化的getter setter方法（合理暴露）
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3.定义类

package cn.vqqc;

public class Student {
    //成员变量
     private String name;
     private  int age;
     private char sex;

    public Student() {
        System.out.println("无参数构造器执行");
    }

    public String getName() {
        return name;
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

4.案例1

package cn.vqqc;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.setName("张三");
        s.setAge(23);
        s.setSex('男');
        System.out.println(s.getName());
        System.out.println(s.getAge());
        System.out.println(s.getSex());

        Student s2 = new Student("李四", 24, '男');
        System.out.println(s2.getName());
        System.out.println(s2.getAge());
        System.out.println(s2.getSex());


    }
}

5.案例2

package cn.vqqc;

public class Test2 {
    public static void main(String[] args) {
        // 目标：复习this的作用。
        Car c = new Car("布加迪威龙", 25000000);
        System.out.println(c.getName());
        System.out.println(c.getPrice());

        c.goWith("法拉利");
        System.out.println(c);
    }
}

6.案例3

package cn.vqqc;

public class Test3 {
    public static void main(String[] args) {
        // 目标：回顾封装的步骤。
        People p = new People();
        p.setAge(23);
        System.out.println(p.getAge());
    }
}

进阶面向对象高级

1.d1_static

1.static：修饰成员变量、修饰成员方法

package cn.vqqcn.d1_static;
public class Student {
    /**
     实例成员变量：无static修饰，属于对象。
     */
    private String name;

    /**
     静态成员方法: 有static修饰，归属于类，可以被共享访问，用类名或者对象名都可以访问。
     */
    public static int getMax(int age1, int age2){
        return age1 > age2 ? age1 : age2;
    }

    /**
     实例方法:属于对象的，只能用对象触发访问
     */
    public void study(){
        System.out.println(name + "在好好学习，天天向上");
    }

    public static void main(String[] args) {
        // 1、类名.静态成员方法
        System.out.println(Student.getMax(10, 3));
        // 注意：同一个类中，访问静态方法，类名可以省略不写。
        System.out.println(getMax(10, 32));

//         study(); // 报错了
        // 2、对象.实例方法
        Student s = new Student();
        s.name = "try栈";
        s.study();

        // 3、对象.静态方法 (语法是可行，但是不推荐)
        System.out.println(s.getMax(13,34));
    }
}

package cn.vqqcn.d1_static;

public class Test3 {

    /**
     静态成员
     */
    public static int onlineNumber = 10;
    public static void test2(){
        System.out.println("==test2==");
    }

    /**
     实例成员
     */
    private String name;
    public void run(){
        System.out.println(name + "跑的快");
    }

    // 3、静态方法中不可以出现this关键字
    public static void test3(){
        // System.out.println(this); // this只能代表当前对象！！
    }

    // 2、实例方法可以访问静态成员，也可以访问实例成员
    public void go(){
        System.out.println(Test3.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        System.out.println(name);
        System.out.println(this);
        run();
    }

    // 1、静态方法只能访问静态成员，不能"直接"访问实例成员。
    public static void test(){
        System.out.println(Test3.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        // System.out.println(name); // 不能直接访问实例成员。
        // run(); // 不能直接访问实例成员。
    }

    public static void main(String[] args) {
        // 目标：理解static 访问相关的语法：面试笔试题，或者以后理解程序很重要的知识（拓展）。
    }
}

package cn.vqqcn.d1_static;

public class User {
    /**
     在线人数。
     注意：static修饰的成员变量：静态成员变量，只在内存中有一份，可以被共享
     */
    public static int onlineNumber = 161;
    /**
     实例成员变量：无static修饰，属于每个对象的，必须用对象名.访问
     */
    private String name;
    private int age;

    public static void main(String[] args) {
        // 目标：理解static修饰成员变量的作用和访问特点。
        // 1、类名.静态成员变量。
        System.out.println(User.onlineNumber);

        // 2、对象名.实例成员变量
        // System.out.println(User.name); // 报错
        User u = new User();
        u.name = "张三";
        u.age = 21;
        System.out.println(u.name);
        System.out.println(u.age);
        u.onlineNumber++; // 新来了一个人
        System.out.println(u.onlineNumber);

        User u2 = new User();
        u2.name = "李四";
        u2.age = 22;
        System.out.println(u2.name);
        System.out.println(u2.age);
        u2.onlineNumber++; // 新来了一个人

        System.out.println(u.onlineNumber);
        System.out.println(User.onlineNumber); // 推荐方式
        // 注意：同一个类中静态成员变量的访问可以省略类名。
        System.out.println(onlineNumber);

    }

}

2.d2_static_util

静态的工具类

随机验证码

package cn.vqqcn.d2_static_util;

public class Check {
}

package cn.vqqcn.d2_static_util;

import java.util.Random;

/**
 工具类
 */
public class vqqcUtil {

    /**
     注意：由于工具类无需创建对象，所以把其构造器私有化会显得很专业！
     */
    private vqqcUtil(){
    }

    /**
     静态方法。
     */
    public static String createVerifyCode(int n){
        // 开发一个验证码：
        // 1、定义一个变量记住验证码。
        String code = "";
        // 2、定义一个变量记住全部验证码字符。
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        // 3、定义一个循环生成几个随机索引，去得到几个字符
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            // 4、获取随机索引对应的字符。链接给code
            int index = r.nextInt(data.length());
            code += data.charAt(index);
        }
        return code;
    }
}

package cn.vqqcn.d2_static_util;

import java.util.Random;

public class Login {
    public static void main(String[] args) {
        // 开发一个验证码：
        System.out.println(vqqcUtil.createVerifyCode(6));
    }
}

3.d3_static_code

1.理解实例和静态代码块

package cn.vqqcn.d3_static_code;

public class StaticDemo1 {

    public static String schoolName;

    /**
     静态代码块：有static修饰，属于类，与类一起优先加载一次，自动触发执行
     作用：可以用于初始化静态资源
     */
     static {
        System.out.println("------静态代码块被触发执行了------");
        schoolName = "try栈";
    }

    public static void main(String[] args) {
        // 目标：先理解静态代码块。
        System.out.println("------main方法执行------");
        System.out.println(schoolName);
    }
}

package cn.vqqcn.d3_static_code;

public class StaticDemo2 {

    private String name;

    public StaticDemo2(){
        System.out.println("===无参构造器被触发执行==");
    }

    /**
     实例代码块：无static修饰，属于对象，每次构建对象时，都会触发一次执行
     初始化实例资源
     */
    {
        name = "张三";
        System.out.println("===实例代码块被触发执行===");
    }

    public static void main(String[] args) {
        // 目标：理解实例代码块（构造代码块）
        StaticDemo2 s1 = new StaticDemo2();
        System.out.println(s1.name);

        StaticDemo2 s2 = new StaticDemo2();
        System.out.println(s2.name);
    }
}

2.集合静态加载成数组案例

package cn.vqqcn.d3_static_code;

import java.util.ArrayList;

public class StaticTest3 {

    /**
     1、定义一个静态的集合，这样这个集合只加载 一个。因为当前房间只需要一副牌
     */
    public static ArrayList<String> cards = new ArrayList<>();

    /**
     2、在程序真正运行main方法前，把54张牌放进去吧，后续游戏可以直接使用了
     */
    static {
        // 3、正式做牌，放到集合中去
        // a、定义一个数组存储全部点数：类型确定了，个数确定了
        String[] sizes = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        // b、定义一个数组存储全部的花色：类型确定了，个数确定了
        String[] colors = {"♥", "♠", "♦", "♣"};
        // c、遍历点数
        for (int i = 0; i < sizes.length; i++) {
            // sizes[i]
            // d、遍历花色
            for (int j = 0; j < colors.length; j++) {
                // colors[j]
                // 一张牌
                String card = sizes[i] + colors[j];
                cards.add(card);
            }
        }
        // e、单独加入大小王
        cards.add("小王");
        cards.add("大王");
    }

    public static void main(String[] args) {
        // 目标：模拟游戏启动前，初始化54张牌数据
        System.out.println("新牌：" + cards);
    }
}

4.d4_static_singleinstance

理解饿汉单例和懒汉单例类

package cn.vqqcn.d4_static_singleinstance;

/**
 使用饿汉单例实现单例类
 */
public class SingleInstance {

    /**
     2、饿汉单例是在获取对象前，对象已经提前准备好了一个
     这个对象只能是一个，所以定义静态成员变量记住
     */
    public static SingleInstance instance = new SingleInstance();

    /**
     1、必须把构造器私有化
     */
    private SingleInstance(){
    }
}

package cn.vqqcn.d4_static_singleinstance;

    /**
        懒汉单例
    */
public class SingleInstance2 {

    /**
     2、定义一个静态的成员变量负责存储一个对象。
     只加载一次，只有一份。
     注意：最好私有化，这样可以避免给别人挖坑！
     */
    private static SingleInstance2 instance;

    /**
     3、提供一个方法，对外返回单例对象。
     */
    public static SingleInstance2 getInstance() {
        if(instance == null){
            // 第一次来拿对象 ：此时需要创建对象。
            instance = new SingleInstance2();
        }
        return instance;
    }


    /**
     1、私有化构造器
     */
    private SingleInstance2(){
    }
}

package cn.vqqcn.d4_static_singleinstance;

public class Test1 {
    public static void main(String[] args) {
        // 目标：理解饿汉单例的设计步骤。
        SingleInstance s1 = SingleInstance.instance;
        SingleInstance s2 = SingleInstance.instance;
        System.out.println(s1 == s2);
    }
}

package cn.vqqcn.d4_static_singleinstance;

public class Test2 {
    public static void main(String[] args) {
        // 目标: 掌握懒汉单例的设计。理解其思想
        SingleInstance2 s1 = SingleInstance2.getInstance();
        SingleInstance2 s2 = SingleInstance2.getInstance();
        System.out.println(s1 == s2);
    }
}

5.d5_extends

1.面向对象的三大特征之二：继承

1.继承

package cn.vqqcn.d5_extends;


/**
 人类：父类
 */
public class People {
    public void run(){
        System.out.println("人会跑~~");
    }
}

package cn.vqqcn.d5_extends;

/**
 学生类：子类
 */
public class Student extends People {

}

package cn.vqqcn.d5_extends;

public class Test {
    public static void main(String[] args) {
        // 目标：认识继承这种关系。搞清楚使用继承的好处
        Student s = new Student();
        s.run();
    }
}

2.继承案例

package cn.vqqcn.d6_extends_test;

/**
 父类
 */
public class People {
    private String name;
    private int age;

    /**
     查看课表
     */
    public void queryCourse(){
        System.out.println(name + "在查看课表");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package cn.vqqcn.d6_extends_test;

/**
 子类
 */
public class Student extends People {

    /**
     独有的行为。填写反馈信息。
     */
    public void writeInfo(){
        System.out.println(getName() + "写下了：学习语法");
    }

}

package cn.vqqcn.d6_extends_test;

public class Teacher {
}

package cn.vqqcn.d6_extends_test;

public class Test {
    public static void main(String[] args) {
        // 目标：理解继承的设计思想。
        Student s = new Student();
        s.setName("try栈");// 使用父类的。
        s.setAge(999);// 使用父类的。
        System.out.println(s.getName());// 使用父类的。
        System.out.println(s.getAge());// 使用父类的。
        s.queryCourse();// 父类的
        s.writeInfo(); // 子类的方法
    }
}

3.理解继承的特点

package cn.vqqcn.d7_extends_feature;


public class Test {
    public static void main(String[] args) {
        // 目标：理解继承的特点
        // 1、子类不能继承父类的构造器
        // 2、子类是否可以继承父类的私有成员？ 是可以继承父类私有成员的，只是不能直接访问
        Tiger t = new Tiger();
//         t.eat();
        // 3、子类是否可以继承父类的静态成员， 不算继承的，只是共享的
        System.out.println(Tiger.location);
    }
}

class Animal{
    private void eat(){
        System.out.println("动物要吃东西");
    }

    public static String location = "长隆动物园";
}

class Tiger extends Animal{

}

4.理解继承后成员的访问特点：就近原则

package cn.vqqcn.d8_extends_field_method;
public class Test {
    public static void main(String[] args) {
        // 目标：理解继承后成员的访问特点：就近原则
        Dog d = new Dog();
        d.run(); // 子类的
        d.lookDoor(); // 子类的
        d.showName();

    }
}

class Animal{
    public String name = "动物名";
    public void run(){
        System.out.println("动物可以跑");
    }
}

class Dog extends Animal{
    public String name = "狗名";

    public void lookDoor(){
        System.out.println("狗可以看门");
    }

    public void showName(){
        String name = "局部名";
        System.out.println(name);
        System.out.println(this.name); // 当前子类对象的name
        System.out.println(super.name); // 找父类的name

        super.run(); // 找父类的方法
        run(); // 子类的run
    }

    public void run(){
        System.out.println("狗跑的贼快");
    }
}

5.认识方法重写

package cn.vqqcn.d9_extends_override;
public class Test {
    public static void main(String[] args) {
        // 目标：认识方法重写
        NewPhone hw = new NewPhone();
        hw.call();
        hw.sendMsg();
    }
}

/**
 新手机：子类
 */
class NewPhone extends Phone{
    // 重写的方法
    // 1、@Override重写校验注解，加上之后，这个方法必须是正确重写的，这样更安全 2、提高程序的可读性，代码优雅！
    // 注意：重写方法的名称和形参列表必须与被重写的方法一模一样
    @Override
    public void call(){
        super.call(); // 先用它爸爸的基本功能
        System.out.println("开始视频通话");
    }
    // 重写的方法
    @Override
    public void sendMsg(){
        super.sendMsg(); // 先用它爸爸的基本功能
        System.out.println("发送有趣的图片");
    }

    // 注意：静态方法不能被重写
//    @Override
//    public static void test(){
//
//    }
}

/**
 旧手机：父类的
 */
class Phone{
    public void call(){
        System.out.println("打电话");
    }

    public void sendMsg(){
        System.out.println("发短信");
    }

    public static void test(){

    }
}

6.认识继承后子类构造器的特点

package cn.vqqcn.d10_extends_constructor;

public class Animal {
    public Animal(){
        System.out.println("父类Animal无参数构造器被执行~");
    }
}

package cn.vqqcn.d10_extends_constructor;


public class Dog extends Animal{
    public Dog(){
        super(); // 写不写都有，默认找父类的无参数构造器执行
        System.out.println("子类Dog无参数构造器被执行");
    }

    public Dog(String name){
        super(); // 写不写都有，默认找父类的无参数构造器执行
        System.out.println("子类Dog有参数构造器被执行");
    }
}

package cn.vqqcn.d10_extends_constructor;

public class Test {
    public static void main(String[] args) {
        // 目标：认识继承后子类构造器的特点
        // 特点：子类的全部构造器默认会先访问父类的无参数构造器再执行自己
        Dog d1 = new Dog();
        System.out.println(d1);

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

        Dog d2 = new Dog("金毛");
        System.out.println(d2);
    }
}

7.理解子类构造器如何去访问父类有参数构造器

package cn.vqqcn.d11_extends_constructor;
public class People {
    private String name;
    private int age;

    public People(){
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package cn.vqqcn.d11_extends_constructor;
public class Teacher extends People{

    public Teacher(){
    }

    public Teacher(String name, int age){
        // 调用父类的有参数构造器：初始化继承自父类的数据
        super(name, age);
    }
}

package cn.vqqcn.d11_extends_constructor;
public class Test {
    public static void main(String[] args) {
        // 目标：学习子类构造器如何去访问父类有参数构造器，还要清楚其作用
        Teacher t = new Teacher("try", 18);
        System.out.println(t.getName());
        System.out.println(t.getAge());
    }
}

8.理解解this的作用：本类构造器中访问本类兄弟构造器

package cn.vqqcn.d12_this;

public class Student {
    private String name;
    private String schoolName;

    public Student() {
    }

    /**
     如果学生不填写学校，默认这个对象
     */
    public Student(String name) {
        // 借用本类兄弟构造器
        this(name, "try栈");
    }

    public Student(String name, String schoolName) {
        // super(); // 必须先初始化父类，再初始化自己
        this.name = name;
        this.schoolName = schoolName;
    }

    public String getName() {
        return name;
    }

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

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}

package cn.vqqcn.d12_this;

public class Test {
    public static void main(String[] args) {
        // 目标：理解this(...)的作用：本类构造器中访问本类兄弟构造器
        Student s1 = new Student("小明", "小红");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());

        /**
         如果学生不填写学校，默认这个对象
         */
        Student s2 = new Student("小王");
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());
    }
}