JavaSE进阶（day01,复习自用）

static

介绍

成员方法的分类：
静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。
实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

1.成员方法的分类和访问分别是什么样的？
静态成员方法（有static修饰，属于类和对象共享）访问格式：
类名.静态成员方法。
对象.静态成员方法。（不推荐）
实例成员方法（无static修饰，属于对象）的访问格式：
对象.实例成员方法。
2.每种成员方法的使用场景是怎么样的？
表示对象自己的行为的，且方法中需要直接访问实例成员，则该方法必须申明成实例方法。
如果该方法是以执行一个通用功能为目的，或者需要方便访问，则可以申明成静态方法

三类

工具类

public class ArrayUtil {

    //私有化构造方法(这个也就是构造器)
    //目的：为了不让外界创建它的对象
    private ArrayUtil(){}

    //方法需要定义为静态的，方便调用
    public static String printArr(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            //i索引arr[i]元素
            if(i == arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    public static double getAverage(double[] arr){
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum/arr.length;
    }

}

public class TestDemo {
    public static void main(String[] args) {
        //测试工具类中的两个方法是否正确
        int[] arr1 = {1,2,3,4,5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);


        double[] arr2 = {1.5,3.7,4.9,5.8,6.6};
        double avg = ArrayUtil.getAverage(arr2);
        System.out.println(avg);


    }
}

注意事项

静态方法只能访问静态的成员，不可以直接访问实例成员。
实例方法可以访问静态的成员，也可以访问实例成员。
静态方法中是不可以出现this关键字的。

/**
 * 总结：
 * 静态方法中没有this关键字 非静态方法默认有this关键字
 * 静态方法中，只能访问静态  静态方法不能访问非静态的东西（如成员变量和成员方法）
 * 非静态方法可以访问所有
 */

public class Student {
    String name;
    int age;
    static String teachername;



    //this:表示当前方法调用者的地址值
    //这个this:是由虚拟机赋值的
    public void show1(Student this){
        System.out.println("this:" + this);
        //下面的this关键字可以省略不写的
        System.out.println(this.name + "," + this.age + "," + this.teachername);

        //调用其他方法
        this.show2();
        this.method();
    }

    public void show2(){
        System.out.println("show2");
    }

    public static void method(){
        //System.out.println("this:" + this);错误，静态方法没有this关键字
        //System.out.println(this.name);静态方法不能调用非静态的成员变量
        //this.show();静态方法没有this关键字
        System.out.println("静态方法");

    }
}

public class StudentTest {
    public static void main(String[] args) {
        Student.teachername = "阿玮老师";

        Student s1 = new Student();
        System.out.println("s1:" + s1);
        s1.name = "张三";
        s1.age = 23;
        s1.show1();

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

        Student s2 = new Student();
        System.out.println("s2:" + s2);
        s2.name = "李四";
        s2.age = 24;
        s2.show1();


    }
}

重新认识main方法

代码块

静态代码块

import java.util.ArrayList;

public class StaticDemo1 {

    public static String schooldName;
    public static ArrayList<String> cards = new ArrayList<>();

    /**
     * 静态代码块：有static修饰，属于类，与类一起优先加载一次，自动触发执行
       作用：可以用于初始化静态资源。
     */

    static{
        System.out.println("-------静态代码块被触发执行了-------");
        schooldName = "黑马";
    }



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

动态代码块

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

单例模式

可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

饿汉单例设计模式

在用类获取对象的时候，对象已经提前为你创建好了。

/**
 * 使用饿汉单例使用单例类
 */
public class SingleInstance {
    //1.必须把构造器私有化
    private SingleInstance(){
    }

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

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

懒汉设计模式

在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。

/**
 * 懒汉单例
 */

public class SingleInstance2 {
    /**
     * 1.私有化构造器
     */
    private SingleInstance2(){
    }

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

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

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


    }

继承

继承概述、使用继承的好处

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。

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

继承设计规范：
子类们相同特征（共性属性，共性方法）放在父类中定义，子类独有的的属性和行为应该定义在子类自己里面。

为什么？
如果子类的独有属性、行为定义在父类中，会导致其它子类也会得到这些属性和行为，这不符合面向对象逻辑。

继承的特点

1. 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
2. Java是单继承模式：一个类只能继承一个直接父类。
3. Java不支持多继承、但是支持多层继承。
4. Java中所有的类都是Object类的子类。

1、子类是否可以继承父类的构造器？
不可以的，子类有自己的构造器，父类构造器用于初始化父类对象。

2、子类是否可以继承父类的私有成员？
可以的，只是不能直接访问。

3、子类是否可以继承父类的静态成员？
有争议的知识点。
子类可以直接使用父类的静态成员（共享）
但个人认为：子类不能继承父类的静态成员。（共享并非继承）

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{

}

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

在子类方法中访问成员（成员变量、成员方法）满足：就近原则
先子类局部范围找
然后子类成员范围找
然后父类成员范围找，如果父类范围还没有找到则报错。

如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？
可以通过super关键字，指定访问父类的成员。

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("狗跑得贼快~~");
    }
}

继承后：方法重写

什么是方法重写？
在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
方法重写的应用场景
当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
子类可以重写父类中的方法。
案例演示：
旧手机的功能只能是基本的打电话，发信息
新手机的功能需要能够：基本的打电话下支持视频通话。基本的发信息下支持发送语音和图片。
@Override重写注解
@Override是放在重写后的方法上，作为重写是否正确的校验注解。
加上该注解后如果重写错误，编译阶段会出现错误提示。
建议重写方法都加@Override注解，代码安全，优雅！
方法重写注意事项和要求
重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
私有方法不能被重写。
子类重写父类方法时，访问权限必须大于或者等于父类 （暂时了解 ：缺省 < protected < public）
子类不能重写父类的静态方法，如果重写会报错的。

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


//旧手机：父类的
class Phone{
    public void call(){//声明不变，重新实现
        System.out.println("打电话~");
    }

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

    public static void test(){

    }

}

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

    //重写的方法
    @Override
    public void sendMsg(){
        super.sendMsg();//先用它爸的基本功能
        System.out.println("发送有趣的图片~");
    }

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

}

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

子类继承父类后构造器的特点：
子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。

为什么？
子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

怎么调用父类构造器的？
子类构造器的第一行语句默认都是：super()，不写也存在。

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

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

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

    }
}

//main函数
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);

    }

}

运行结果：

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

super调用父类有参数构造器的作用：
初始化继承自父类的数据。

如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢？
会报错。因为子类默认是调用父类无参构造器的。

如何解决？
子类构造器中可以通过书写 super(…)，手动调用父类的有参数构造器

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 Teacher extends People{
    public Teacher(){

    }

    public Teacher(String name,int age){
//        不行，这样写会报错
//        this.name = name;
//        this.age = age;
        //要调用父类的有参数构造器：初试化继承父类的数据
        super(name, age);
    }
}

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

this、super使用总结

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

    public Student() {
    }

    /**
     *  如果学生不填写学校，默认这个对象的学校是黑马
     */

    public Student(String name){
        //借用本类兄弟构造器
        this(name,"黑马程序员");
        //这里是没有super的
        //this.name = name;
    }


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

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

        Student s2 = new Student("张三丰");
        s2.getName();
        System.out.println(s2.getSchoolName());
    }
}