Java - day10 - 面向对象进阶 - static、单例、代码块、继承

static是什么

• static是静态的意思，可以修饰成员变量和成员方法。
• static修饰成员变量表示该成员变量只在内存中只存储一份，可以被共享访问、修改。
  例：

public class user {
       //静态成员变量
       public static int onlineNumber= 161;
       private String name;
       private int age;
}

成员变量可以分为2类

• 静态成员变量（有static修饰，属于类，内存中加载一次）︰常表示如在线人数信息、等需要被共享的信息，可以被共享访问。

public class User {
     //静态成员变量
    public static string onlineNumber= 161;
}

• 类名.静态成员变量。(推荐)
• 对象.静态成员变量。(不推荐)
• 实例成员变量（无static修饰，存在于每个对象中)︰常表示姓名name、年龄age、等属于每个对象的信息。

  public class User {
          public static string onlineNumber= 161;
          //实例成员变量
          private String name;
          private int age;
  }

• 对象.实例成员变量

实例：

public class User {
    // 在线人数信息：静态成员变量
    public static int onLineNumber = 161;
    // 实例成员变量
    private String name;
    private int age;

    public static void main(String[] args) {
        // 1、类名.静态成员变量
        User.onLineNumber++;
        // 注意：同一个类中访问静态成员变量，类名可以省略不写
        System.out.println(onLineNumber);

        // 2、对象.实例成员变量
        // System.out.println(name);
        User u1 = new User();
        u1.name = "猪八戒";
        u1.age = 36;
        System.out.println(u1.name);
        System.out.println(u1.age);
        // 对象.静态成员变量(不推荐这样访问)
        u1.onLineNumber++;

        User u2 = new User();
        u2.name = "孙悟空";
        u2.age = 38;
        System.out.println(u2.name);
        System.out.println(u2.age);
        // 对象.静态成员变量(不推荐这样访问)
        u2.onLineNumber++;

        System.out.println(onLineNumber);

    }
}

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

成员方法的分类:

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

使用场景

• 表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
• 如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。

实例：

public class Student {
    private String name;
    private int age;

    /**
     实例方法：无static修饰，属于对象的，通常表示对象自己的行为，可以访问对象的成员变量
     */
    public void study(){
        System.out.println(name + "在好好学习，天天向上~~");
    }

    /**
     静态方法：有static修饰，属于类，可以被类和对象共享访问。
     */
    public static void getMax(int a, int b){
        System.out.println(a > b ? a : b);
    }

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

        // 2、对象.实例方法
        // study(); // 报错的
        Student s = new Student();
        s.name = "全蛋儿";
        s.study();

        // 3、对象.静态方法(不推荐)
        s.getMax(300,20);
    }
}

static访问注意事项:

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

static应用知识:工具类

工具类是什么?

• 类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的。
• 案例:在企业的管理系统中，通常需要在一个系统的很多业务处使用验证码进行防刷新等安全控制。
• 问题:同一个功能多处开发，会出现代码重复度过高。

使用工具类的好处

• 一是调用方便，二是提高了代码复用（一次编写，处处可用)

实例：（验证码）

import java.util.Random;

public class 验证码 {
    public static String creat(int n) {
        String code = "";
        String data = "qwrertyyuyiiiiopdasfglkjznnmbzxv";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(data.length());
            code += data.charAt(index);
        }
        return  code;
    }
}

 //调用
public class 验证码调用 {
    public static void main(String[] args) {
        System.out.println(验证码.creat(6));
    }
}

为什么工具类中的方法不用实例方法做?

• 实例方法需要创建对象调用。
• 此时用对象只是为了调用方法，这样只会浪费内存。

工具类定义时的其他要求:

• 由于工具里面都是静态方法，直接用类名即可访问，因此，工具类无需创建对象，建议将工具类的构造器进行私有。

实例：

public class shuzu {
    public class Array {
        private Array(){}
    }

    public static String toString(int[] arr) {
        if (arr == null){
            return null;
        }

        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            result += (i == arr.length -1 ? arr[i] : arr[i] + ",");
        }

        result += "]";
        return  result;
    }
}

//调用
public class shuzudiaoyong {
    public static void main(String[] args) {
        int[ ] arr = null;
        int[ ] arr1 = {};
        int[ ] arr2 = {12,8,8,8,6};
        System.out.println(shuzu.toString(arr)) ;
        System.out.println(shuzu.toString(arr1));
        System.out.println(shuzu.toString(arr2));
    }

}

代码块概述

• 代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类)，定义在类中方法外。
• 在Java类下，使用{}括起来的代码被称为代码块。

代码块分为

静态代码块:

• 格式: static
• 特点:需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次。
• 使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

构造代码块（了解，见的少):

• 格式:{}
• 特点:每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
• 使用场景:初始化实例资源。

实例：（静态代码块）

package com.itheima.d5_static_codeblock;

public class TestDemo1 {

    public static String schoolName;

    public static void main(String[] args) {
        // 目标：学习静态代码块的特点、基本作用
        System.out.println("=========main方法被执行输出===========");
        System.out.println(schoolName);
    }

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

实例2：（构造代码块）

package com.itheima.d5_static_codeblock;

public class TestDemo2 {

    private String name;

    /**
       属于对象的，与对象一起加载，自动触发执行。
     */
    {
        System.out.println("==构造代码块被触发执行一次==");
        name = "张麻子";
    }

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

    public static void main(String[] args) {
        // 目标：学习构造代码块的特点、基本作用
        TestDemo2 t = new TestDemo2();
        System.out.println(t.name);

        TestDemo2 t1 = new TestDemo2();
        System.out.println(t1.name);
    }

}

静态代码块的应用案例

实例：

    import java.util.ArrayList;

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

    static {
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] colors = {"♠", "♥", "♣", "♦"};

        for (int i = 0; i < colors.length; i++) {
            for (int j = 0; j < colors.length; j++) {
                String card =sizes[i] + colors[i];
                cards.add(card);
            }
            cards.add("小牌");
            cards.add("大牌");
        }
    }
    public static void main(String[] args) {
        System.out.println("新牌：" +  cards);
    }
}

static应用知识:单例设计模式

• 设计模式、单例模式介绍、饿汉单例模式、懒汉单例模式

什么是设计模式(Design pattern)

• 开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
• 设计模式有20多种，对应20多种软件开发中会遇到的问题。

学设计模式主要是学2点:

• 第一:这种模式用来解决什么问题。
• 第二:遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

单例模式

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

单例的实现方式很多

• 饿汉单例模式。
• 懒汉单例模式。
• 。。。。。。。

饿汉单例设计模式

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

设计步骤:

• 定义一个类，把构造器私有。
• 定义一个静态变量存储一个对象。

例：

    public class SingleInstance1 {
    //目标：学会使用恶汉单例模式设计单例类
    //static修饰的成员变量，静态成员变量，加载一次，只有一份
    public static  SingleInstance1 instance = new SingleInstance1();

    //必须私有构造器：私有构造器对外不能被访问。
    private SingleInstance1(){
    }
}

public class Test {
    public static void main(String[] args) {
        SingleInstance1 s1 = SingleInstance1.instance;
        SingleInstance1 s2 = SingleInstance1.instance;
        SingleInstance1 s3 = SingleInstance1.instance;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s1 == s2);
        /**
         SingleInstance1@7ef20235
         SingleInstance1@7ef20235
         SingleInstance1@7ef20235
         true
         */
    }
}

懒汉单例设计模式

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

设计步骤:

• 定义一个类，把构造器私有。
• 定义一个静态变量存储一个对象.
• 提供一个返回单例对象的方法

实例：

package lanhan;

//目标：设计懒汉单例
public class SingleInstance2 {
    //2、定义一个静态的成员变量用于存储一个对象，一开始不要初始化对象，因为人家是懒汉
    private static SingleInstance2 instance;

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

    //3、提供一个方法暴露，真正调用这个方法的时候才创建一个单例对象
    public static SingleInstance2 getInstance(){
        if (instance == null){  // 第一次来拿对象，为他做一个对象
            instance = new SingleInstance2();
        }
        return instance;
    }
}

package lanhan;
public class test2 {
    public static void main(String[] args) {
        // 得到一个对象
        SingleInstance2 s1 = SingleInstance2.getInstance();
        SingleInstance2 s2 = SingleInstance2.getInstance();
        System.out.println(s1 == s2);
    }
}

面向对象三大特征之二:继承

• 继承概述、使用继承的好处
• 继承的设计规范、内存运行原理
• 继承的特点
• 继承后:成员变量、成员方法的访问特点
• 继承后:方法重写
• 继承后:子类构造器的特点
• 继承后:子类构造器访问父类有参构造器
• this、super使用总结

什么是继承?

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

  public class Student extends People {}

• Student称为子类（派生类)，People称为父类(基类或超类)。
• 作用:当子类继承父类后，就可以直接使用父类公共的属性和方法了

使用继承的好处

• 可以提高代码的复用性。

继承设计规范:

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

为什么?

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

实例：

package jicheng;

public class People {
    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;
    }

    private String name;
    private int age;
}

package jicheng;

public class test {
    public static void main(String[] args) {
        // 创建子类对象，看是否可以使用父类的属性和行为
        Student s = new Student();
        s.setName("西门"); // 父类的
        s.setAge(25);// 父类的
        System.out.println(s.getName());// 父类的
        System.out.println(s.getAge());// 父类的
        s.study();
    }
}

package jicheng;

public class Student extends People {
    public  void study(){
        System.out.println(getName() + "学生开始学习");
    }
}

package jicheng;

public class Teacher {
    public void teach(){
        System.out.println("laos");
    }
}

继承的特点

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

子类是否可以继承父类的构造器?

• 不可以的，子类有自己的构造器，父类构造器用于初始化父类对象。

子类是否可以继承父类的私有成员?

• 可以的，只是不能直接访问。

子类是否可以继承父类的静态成员?

• 有争议的知识点。
• 子类可以直接使用父类的静态成员(共享)
• 但个人认为:子类不能继承父类的静态成员。(共享并非继承)

Java只支持单继承，不支持多继承。

• 单继承:子类只能继承一个直接父类
• 不支持多继承:子类不能同时继承多个父类（二义性）

Java支持多层继承

• 子类A继承父类B，父类B可以继承父类C

Object特点:

• Java中所有类，要么直接继承了Object,要么默认继承了Object ,要么间接继承了Object, Object是祖宗类。

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

在子类方法中访问成员(成员变量、成员方法）满足:就近原则

• 先子类局部范围找
• 然后子类成员范围找
• 然后父类成员范围找，如果父类范围还没有找到则报错!

如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办?

• 可以通过super关键字，指定访问父类的成员。
• 格式: super.父类成员变量/父类成员方法

继承后:方法重写

什么是方法重写?

• 在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

方法重写的应用场景

• 当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
• 子类可以重写父类中的方法。

案例演示:

• 旧手机的功能只能是基本的打电话，发信息
• 新手机的功能需要能够:基本的打电话下支持视频通话。基本的发信息下支持发送语音和图片。

实例：

package ffcx;
public class Test {
    //方法重写
    public static void main(String[] args) {
        NewPhone hw = new NewPhone();
        hw.call();
        hw.sendMsg();
    }
}

//新手机:子类
class NewPhone extends Phone{
    //重写的方法
    public void call(){
        super.call(); //先用它爸爸的基本功能
        System.out.println("开始视频通话~~");
    }
    //重写的方法
    public void sendMsg(){
        super.sendMsg();//先用它爸爸的基本功能
        System.out.println("发送有趣的图片~");
    }
}

//旧手机:父类
class Phone{
    public void call(){
        System.out.println("打电话~");
    }
    public void sendMsg (){
        System.out.println("发短信~");
    }
}

@Override重写注解

• @Override是放在重写后的方法上，作为重写是否正确的校验注解。
• 加上该注解后如果重写错误，编译阶段会出现错误提示。
• 建议重写方法都加@Override注解，代码安全，优雅!

方法重写注意事项和要求

• 重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。

子类继承父类后构造器的特点:

• 子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。

为什么?

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

怎么调用父类构造器的?

• 子类构造器的第一行语句默认都是:super()，不写也存在。

super调用父类有参数构造器的作用:

• 初始化继承自父类的数据。

如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢?

• 会报错。因为子类默认是调用父类无参构造器的。

如何解决?

• 子类构造器中可以通过书写super(...)，手动调用父类的有参数构造器

实例：

package this_super;

public class test {
    public static void main(String[] args) {
        student s1 = new student("xiaobai","xiaobai2");
        System.out.println(s1.getName()); //xiaobai
        System.out.println(s1.getSchoolName()); //xiaobai2

        student s2 = new student("lisi");
        System.out.println(s2.getName()); //lisi
        System.out.println(s2.getSchoolName());  //湛江
    }
}

package this_super;

public class student {
    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 student(String name){
        this(name,"湛江");
    }

    public student(String name, String schoolName) {
        this.name = name;
        this.schoolName = schoolName;
    }

    private String name;
    private String schoolName;

}