3. Java面对对象（上）

---

1. 设计对象并使用

1.1 设计类，创建对象并使用

1.2 定义类的注意事项

2. 对象内存图

2.1 多个对象的内存图

2.2 两个变量指向同一个对象内存图

3. 构造器

4. this关键字

5. 封装 （OOP三大特征之一）

6. 标准JavaBean

7. 成员变量和局部变量的区别

8. 项目设计：ATM

9. static关键字

9.1 static的作用、修饰成员变量的用法

9.2 static修饰成员变量的内存原理

9.3 static修饰成员方法的基本用法

9.4 static修饰成员方法的内存原理

9.5 static实际应用案例：设计工具类

import java.util.Random;

public class VerifyTool { //工具类
    //私有工具类的构造器 -> 不让工具类对外产生对象
    private VerifyTool(){}

	//静态方法：
    public static String createCode(int n){
        String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
        String code = "";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(chars.length());
            code += chars.charAt(index);
        }
        return code;
    }
}

public class Register {
    public static void main(String[] args) {
        System.out.println("验证码：" + VerifyTool.createCode(5));
    }
}
//验证码：XIvxe

public class Login {
    public static void main(String[] args) {
        System.out.println("验证码：" + VerifyTool.createCode(10));
    }
}
//验证码：Xw4xW1OKWo

示例：

public class ArrayUtils {
    private ArrayUtils(){}

    public static String toString(int[] arr){
        if(arr != null) {
            String result = "[";
            for (int i = 0; i < arr.length; i++) {
                result += (i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
            result += "]";
            return result;
        }else{
            return null;
        }
    }

    public static double getAverage(int[] arr){
        int max = arr[0];
        int min = arr[0];
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
            if (arr[i] < min){
                min = arr[i];
            }
            sum += arr[i];
        }
        return (sum - max - min)*1.0 / (arr.length - 2);
    }
}

public class Test {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40};
        System.out.println(arr);
        System.out.println(ArrayUtils.toString(arr));
        System.out.println(ArrayUtils.getAverage(arr));

        int[] arr1 = null;
        System.out.println(ArrayUtils.toString(arr1));
        int[] arr2 = {};
        System.out.println(ArrayUtils.toString(arr2));
    }
}
//[I@776ec8df
//[10, 20, 30, 40]
//25.0

//null
//[]

9.6 static的注意事项总结[面试热点]

public class Test {
    //静态成员变量
    public static int onlineNumber;
    //实例成员变量
    private String name;

    public static void getMax(){
        //1.静态方法可以直接访问静态成员
        System.out.println(Test.onlineNumber);
        System.out.println(onlineNumber);

        //3.静态方法不能出现this关键字
        //System.out.println(this);
    }

    public void run(){
        //2.实例方法可以直接访问静态成员，也可以访问实例成员
        System.out.println(Test.onlineNumber);
        System.out.println(onlineNumber);
        Test.getMax();
        getMax();

        System.out.println(name);
        sing();
    }

    public void sing(){}
}

9.7 static应用：代码块

public class Test {
    public static String schoolName;

    public static void main(String[] args) {
        System.out.println("========main方法被执行输出===========");
        System.out.println(schoolName);
    }

    /**
     静态代码块
     特点：与类一起加载，自动触发一次，优先执行
     作用：可以在程序加载时进行静态数据的初始化操作（准备内容）
     */
    static {
        System.out.println("=========静态代码块被除非执行=========");
        schoolName = "春田花花小学";
    }
}
//=========静态代码块被除非执行=========
//========main方法被执行输出===========
//春田花花小学

示例：

import java.util.ArrayList;

public class Test {
    public static ArrayList<String> cards = new ArrayList<>();

    //在游戏启动前需要准备好54张牌进去，使用静态代码块进行初始化
    static{
        String[] colors = {"黑桃","红桃","方块","梅花"};
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        for (int i = 0; i < sizes.length; i++) {
            for (int j = 0; j < colors.length; j++) {
                cards.add(sizes[i] + colors[j]);
            }
        }
        cards.add("小王");
        cards.add("大王");
    }

    public static void main(String[] args) {
        System.out.println("新牌:" + cards);
    }
}

9.8 static应用： 单例设计模式

9.8.1 饿汉单例设计模式

public class SingleInstance {
    //定义一个公开的静态的成员变量存储一个类的对象
    //饿汉：在这里加载静态变量的时候就创建对象了
    public static SingleInstance instance = new SingleInstance();

    //把构造器私有起来
    private SingleInstance(){}
}

public class Test {
    public static void main(String[] args) {
        SingleInstance s1 = SingleInstance.instance;
        SingleInstance s2 = SingleInstance.instance;
        SingleInstance s3 = SingleInstance.instance;

        System.out.println(s1); //com.buluchacha.SingleInstance@4eec7777
        System.out.println(s2); //com.buluchacha.SingleInstance@4eec7777
        System.out.println(s3); //com.buluchacha.SingleInstance@4eec7777
        System.out.println(s1 == s3); //true
    }
}

9.8.2 懒汉单例设计模式

public class SingleInstance {
    //定义一个私有的静态的成员变量存储本类的对象，注意不能初始化对象
    //饿汉：在这里加载静态变量的时候就创建对象了
    private static SingleInstance instance; //null

    //把构造器私有起来
    private SingleInstance(){}

    //定义一个方法，让其他地方可以来调用获取一个对象
    public static SingleInstance getInstance(){
        if (instance == null){
            //第一次来获取对象
            instance = new SingleInstance();
        }
        return instance;
    }
}

public class Test {
    public static void main(String[] args) {
        SingleInstance s1 = SingleInstance.getInstance();
        SingleInstance s2 = SingleInstance.getInstance();
        SingleInstance s3 = SingleInstance.getInstance();

        System.out.println(s1); //com.buluchacha.SingleInstance@4eec7777
        System.out.println(s2); //com.buluchacha.SingleInstance@4eec7777
        System.out.println(s3); //com.buluchacha.SingleInstance@4eec7777
        System.out.println(s1 == s3); //true
    }
}

10. 继承（OOP三大特征之一）

10.1 概述

10.2 继承的设计规范、内存运行原理

10.3 继承的特点

10.4 继承后：成员变量、成员方法的访问特点

public class ExtendsDemo {
    public static void main(String[] args) {
        Wolf w = new Wolf();
        System.out.println(w.name); //子类的
        w.showName();
    }
}

class Animal{
    public String name = "父类动物";
}

class Wolf extends Animal{
    public String name = "子类动物";

    public void showName(){
        String name = "局部名称";
        System.out.println(name); //局部的
        System.out.println(this.name); //子类name
        System.out.println(super.name); //父类name
    }
}
//子类动物
//局部名称
//子类动物
//父类动物

10.5 继承后：方法重写

10.6 继承后：子类构造器的特点

public class ExtendsDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
        System.out.println("===========");
        Cat c1 = new Cat("叮当猫");
    }
}

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

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

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

10.7 继承后：子类构造器访问父类有参构造器

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;
    }
}

public class Student extends People{
    private String className;

    public Student() {}

    public Student(String name, int age, String className) {
        super(name, age);
        this.className = className;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student("MIKE", 23, "数学一班");
        System.out.println(s.getName()); //MIKE
        System.out.println(s.getAge()); //23
        System.out.println(s.getClassName()); //数学一班
    }
}

10.8 int、super使用总结