面向对象高级

35、面向对象高级
学前建议：
*多关注语法的基本作用
*多思考、练习、记忆
*要自信，后面用起来就会了
36、static修饰成员变量
static：叫静态，可以修饰成员变量、成员方法。
成员变量按照有无static修饰，分为两种：
*类变量：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。
*实例变量（对象的变量）：无static修饰，属于每个对象的。
eg：

public class Student {
    //类变量
    static String name;-------->>有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。

    int age;

}

类变量：属于类，与类一起加载一次，在内存中只有一份，可以被类和类的所有对象共享。
实例变量：属于每个对象，每个对象中都有一份，只能用对象访问。
类变量的应用场景，在开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以被定义成类变量来记住。
成员变量有几种？各自在什么情况下定义？
类变量：数据只需要一份，且需要被共享（访问、修改）
实例变量：每个对象都要有一份，数据各不同（如：name、score、age）
访问自己类中的类变量，是否可以省略类名不写？
可以。注意：在某个类中访问其他类里的变量，必须带类名访问。
static修饰成员方法
类方法：有static修饰的成远方法，属于类，可以直接用类名访问，也可以用对象访问。
一般格式：类名.类方法（推荐）
其他格式：对象名.类方法（不推荐）
实例方法：无static修饰的成员方法，属于对象。
static修饰成员方法的应用场景：类方法最常见的应用场景是做工具类。
工具类：工具类冲的方法都是一些类方法：每个方法都是用来完成一个功能的，工具类是开发人员共同使用的。
使用类方法来设计工具类有什么好处：
提高了代码的复用；调用方便，提高了开发效率。
使用类方法、实例方法时的几点注意事项
*类方法中可以直接访问类的成员，不可以直接访问实例成员。
*实例方法中既可以直接访问类成员，也可以直接访问实例成员。
*实例方法中可以出现this关键字，类方法中不可以出现this关键字。
36、代码块
代码块概述：代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类）。
代码块分为两种：
*静态代码块：
--->格式：static[]
--->特点：类加载时自动执行，由于类只会加载一次，所以静态代码块只会执行一次。
--->作用：完成类的初始化。例如：对类变量的初始化赋值。
*实例代码块：
--->格式：[]
--->特点：每次创建对象时，执行实例代码块，并在构造器前执行。
--->作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。
37、单例设计模式
什么是设计模式：一个问题通常有n种解法，其中有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。 
设计模式有20多种，对应20多种软件开发中会遇到的问题。
单例设计模式：
确保一个类只有一个对象。
写法：
*把类的构造器私有。
*定义一个变量记住类的一个对象。
*定义一个方法返回对象。
eg：

public class A{
    //2、定义一个类变量记住类的一个对象
    private static  A a = new A();

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

    }


    //3、定义一个类方法返回对象
    public static A getobject(){
    return a;
    }
} 

单例模式的应用场景和好处：
*任务管理器对象，获取运行时对象。
*在这些业务场景下，使用单例模式，可以避免浪费内存。
饿汉式单例的特点：在获取类的对象时，对象已经创建好了。
懒汉式单例模式：
特点：拿对象时才开始创建对象。
写法：
*把类的构造器私有。
*定义一个变量用于存储对象。
*提供一个类方法，保证返回的是同一个对象。
eg：

public class B{
    //2、定义一个变量，用于存储这个类的一个对象
    private static B b;

    //1、把类的构造器私有
    private B(){

    }

    //3、定义一个类方法，这个方法要保证第一次调用时才创建一个对象，后面调用时都会用这同一个对象返回。
    public static B getInstance(){
    if(b == null){
        b = new B();
    }
    return b;
    }
}

38、继承
什么是继承：Java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起父子关系。
继承的特点：子类能继承父类的非私有成员（成员变量、成员方法）。
带继承关系的类，Java会怎么创建它的对象？对象创建出来后，可以直接访问哪些成员？
*带继承关系的类，Java会用类和其父类，这多张设计图来一起创建类的对象。
*对象直接访问什么成员，是有父子类这多张设计图共同决定的，这多张设计图对外暴漏了什么成员，对象就可以访问什么成员。
继承的好处、应用场景：
*减少重复代码的编写，提高代码的复用性。
39、继承相关的注意事项：
*权限修饰符：public private protected、缺省（后面两个很少用到）
什么是权限修饰符：就是用来限制类中的成员（成员变量、成员方法、构造器、代码块...）能够被访问的范围。
40、继承相关的两个注意事项：
*Java是单继承的：一个类只能继承一个直接父类；Java中的类不支持多继承，但支持多层继承。
*Object类时Java中所有类的祖宗。
41、方法重写
什么是方法重写：当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称、参数列表一样的方法，
去覆盖父类的这个方法。
注意：重写后，方法的访问，Java会遵循就近原则。
重写小技巧：
*使用@Override注解，它可以指定Java编译器，检查我们方法重写的格式是否正确，代码可读性也会更好。

package com.wangsen.d7_op;

import java.util.ArrayList;

public class StudentOperatorImpl2 implements StudentOperator{
    @Override
    public void printAllInfo(ArrayList<Student> students) {
        System.out.println("-----------------全班全部学生信息如下-------------------");
        int count1 = 0;
        int count2 = 0;
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            if (s.getSex()=='男'){
                count1++;
            }else{
                count2++;
            }
            System.out.println("姓名:"+s.getName()+" 性别:"+s.getSex()+" 成绩:"+s.getSocre());
        }
        System.out.println("男生人数:"+count1+" 女生人数:"+count2);
        System.out.println("-------------------------------------------------");
    }

    @Override
    public void printaverageScore(ArrayList<Student> students) {
        double allscore = 0;
        double max = students.get(0).getSocre();
        double min = students.get(0).getSocre();
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            if (s.getSocre()>max) max = s.getSocre();
            if (s.getSocre()<min) min = s.getSocre();
            allscore += s.getSocre();
            }
        System.out.println("最高分为:"+max+" 最低分为:"+min);
        System.out.println("学生平均成绩:" + (allscore-min-max) / (students.size()-2));
    }
}

*子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限（public>protected>缺省）。
*重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
*私有方法，静态方法不能被重写，如果重写会报错的。
总结：申明不变，重新实现。
方法重写再开发中的常见应用场景：
*子类重写Object类的toString（）方法，以便返回对象的内容。
42、子类中访问其他成员的特点
在子类中访问其他成员（成员变量、成员方法），是依照就近原则的。
*先子类局部范围中找。
*然后子类成员范围找。
*然后父类成员范围找，如果父类范围还没有找到则会报错，
如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？
*可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法。
43、子类构造器的特点
*子类的全部构造器，都会先调用父类的构造器，再执行自己。
子类构造器是如何实现调用父类构造器的：
*默认情况下，子类全部构造器的代码第一行都是super（）（写不写都有），他会调用父类的无参数构造器。
*如果父类没有无参数构造器，则我们必须在子类构造器的第一行手写super（...）,指定去调用父类的有参数构造器。
子类构造器的常见应用场景
子类构造器可以通过调用父类构造器，把对象中包含父类这部分的数据先初始化赋值，再回来把对象里包含子类这部分的数据也进行初始化赋值。
补充知识：this（...）调用兄弟构造器
任意类的构造器中，是可以通过this（...）去调用该类的其他构造器的。
this(...)、super(...)都只能放在构造器第一行，因此，有了this(...)就不能写super(...)了，反之亦然。
44、多态
什么是多态：多态是在继承/实现情况下的一种现象，表现为：对象多态、行为多态。
多态的前提：
*有继承/实现关系；存在父类引用子类对象；存在方法重写。
多态的一个注意事项
：多态是对象、行为的多态，Java中的属性（成员变量）不谈多态。
45、使用多态的好处
*在多态形式下，右边对象是解耦合的，更便于扩展和维护。
*定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利。
多态下不能直接使用子类的独有功能，怎么解决？
多态下的类型转换问题
自动类型转换： 父类 变量名 = new 子类();
强制类型转换： 子类 变量名 = (子类) 父类变量
强制类型转换的一个注意事项：
存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。
运行时，如果发现对象的真实类型与强转后类型不同，就会报类型转换异常（ClassCastException）的错误出来。
46、final
*final 关键字是最终的意思，可以修饰（类、方法、变量）
*修饰类：该类被称为最终类，特点是不能被继承了。
*修饰方法：该方法被称为最终方法，特点是不能被重写了。
*修饰变量：该变量只能被赋值一次。
final修饰变量的注意
*final修饰基本类型的变量，变量存储的数据不能被改变。
*final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。
47、常量详解
使用了static final修饰的成员变量就被称为常量。
作用：通常用于记录系统的配置信息。
注意！常量名的命名规范：建议使用大写英文单词，多个单词使用下划线连接起来。
使用常量记录系统配置信息的优势、执行原理
*代码可读性更好，可维护性也更好。
*程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接使用字面量的性能是一样的。
48、抽象类
什么是抽象类：在Java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。
abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。注意：抽象方法只用方法签名，不能写方法体。
一般格式：
修饰符 abstract class 类名{
        修饰符 abstract返回值类型 方法名称(形参列表);
}
抽象类的注意事项、特点：
*抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
*类该有的成员（成员变量、方法、构造器）抽象类都可以有。
*抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
*一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
使用抽象类的好处：
父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现。我们设计成这样的抽象类，就是为了更好的支持多态。
抽象类的常见应用场景：模板设计方法设计模式
模板方法设计模式解决了方法中存在重复代码的问题。
模板方法设计模式的写法：
*定义一个抽象类。
*在里面定义两个方法。
**一个是模板方法：把相同代码放里面去。
**一个是抽象方法：具体实现交给子类完成。
49、接口
认识接口：Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊结构：接口。
一般模式：
public interface 接口名{
    //成员变量（常量）
    //成员方法（抽象方法）
}
注意：接口不能创建对象；接口是用来被类实现（implements）的，实现接口的类成为实现类。
格式
修饰符 class 实现类 implements 接口1，接口2，接口3...{

}
一个类可以实现多个接口（可以理解成干爹），实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类
*******接口的好处：
*弥补了类单继承的不足，一个类同时可以实现多个接口。
*让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。
50、接口的其他细节：
JDK8开始，接口中新增的三种方法：

默认方法：使用default修饰，使用实现类的对象调用。
静态方法：static修饰，必须用当前接口名调用。
私有方法：private修饰，jdk9开始才有的，只能在接口内部被调用
它们都会默认被public修饰
*JDK8开始，接口中为啥要新增这些方法？
增强了接口的能力，更便于项目的扩展和维护。
51、接口的其他细节：接口的多继承、使用接口的注意事项：
一个接口可以同时继承多个接口

public interrface C extends B，A{

}

接口多继承的作用：
便于类去实现。
接口的其他注意事项（了解）
*一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。
*一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。
*一个类继承了父类，又同时实现了接口，父类中和接口有同名的默认方法，实现类会优先用父类的。
*一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可