第三章：向上转型与向下转型、多态、单例设计模式

Java设计原则之：ocp（开闭原则）：即对扩展开放，对修改关闭
O:Open
C:Close
P:Principle

一：向上转型和向下转型

（1）向上转型

1. 是指父类的引用指向子类的对象：person p = new Student();
2. 向上转型必须要有继承关系
3. 当我们调用方法时，编译时：会先判断父类中有没有这个方法，如果没有编译不通过；运行时：会先判断子类是否有重写父类的方法，如果有，那么调用的是子类重写后的方法！
4. 父类的引用不能调用子类特有的属性和行为。
5. 优点：增强了程序的扩展性，减少了程序的修改。
6. 缺点：不能访问子类的特有成员

public class Persion {
    private String name;
    private String sex;
    private int age;

    public Persion() {
    }
    public void show(){
     System.out.println("persion------>啊啊啊啊");
    }
    

public class Student extends Persion {
    private double score;
    private String no;

    public Student() {
    }
     @Override
    public void show() {
        System.out.println("student-------》噢噢噢噢");
    }

Person p = new Student();		//向上转型（自动类型提升）

（2）向下转型

1. 就是把父类的引用强制转化为子类的对象：((Student) persion).getScore();
2. 这是为了访问子类的特有成员，开发中不常用
3. 使用时需要使用instanceof关键字判断这两个对象是否存在继承关系才能进行安全的进行向下转型；如：人类1指向学生，人类2指向老师，人类1不能向下转型成老师，人类2不能向下转型成学生。

（3）总结

1. 向上转型：父类引用指向子类的对象，调用的方法必须在父类中存在，如果此方法在子类中不存在，那么调用的是父类的方法，如果存在，那么是调用子类的（重写）
2. 向下转型：父类引用转化为子类的对象，如果调用的是子类的特有的成员，那么就需要进行向下转型。
3. 优点：向上转型增加了程序的扩展，向下转型可以访问到子类特有的成员
4. 缺点：向上转型不能访问子类特有的成员，向下转型不能增强程序的扩展性

二：java中final和static关键字的详解

（1）final关键字

1. final译为最终的意思。
2. final修饰的类不能被继承，即不能再有子类。
3. final修饰的方法不能被重写
4. final修饰的变量为常量，需要赋初始值值，其所有字母大写，不能被修改

（2）static关键字

1. static：静态的

2. static修饰的成员变量是类级别的全局变量，是被这个类的所有对象所共同拥有的一个属性，非静态成员变量是对象级别的全局变量，被每个类独自拥有一份。

3. 从加载时机来看：静态的成员在类构造并加载的时候就已经位其开辟了一个运行空间，而非静态的成员需要new对象实例化才会为其分配空间。这样其加载顺序的不同就意味着：静态成员不可以访问非静态成员（可能不会new这个对象，再取调用就会报错咯），非静态成员可以访问静态成员

4. 加载顺序：
   ①.加载父类的静态成员变量—>静态成员方法
   ②.加载子类的静态成员变量—>静态成员方法
   ③.加载父类的成员变量------->成员方法
   ④.加载子类的成员变量------->成员方法

5. 我们调用静态的成员时，一般用类名.静态成员来调用

三、面向对象三大特性------多态

（1）多态的定义

1. 多态就是：一种引用具有多种不同形态。是向上转型的。
2. 多态的条件：1.必须要有继承；2.要子类重写父类的方法；3.父类引用指向子类的对象

（2）静态多态性-------------重载（overload）

1. 重载是发生在同一个类中的多态性。我们调用方法时，系统会根据我们输入的参数列表的不同从而判断我们需要调用的是何种方法
2. 方法重载发生在同一个类中，方法名相同，参数列表不同的多个方法就构成了方法的重载
3. 简称：一同（方法名相同）一不同（参数列表不同）
4. 参数列表包括：参数类型，参数个数，参数顺序！只要有一个不同就是不同的参数
5. 方法的返回值类型和权限修饰符不同不能判断是否构成重载的因素
6. 同一个类中多个构造方法也构成重载，特殊在于没有返回值和方法名固定。

 //方法的重载---------->静态多态性
    public int method(int a){
        return a;
    }
    //参数个数不同
    public int method(int a,int b){
        return a + b;
    }
    //参输类型不同
    public float method(float a,int b){
        return a + b;
    }
    //参数列表顺序不同
    public float method(int b,float a){
        return a + b;
    }
    //改变返回类型不构成重载
//    public float method(int a,int b){
//        return a + b;
//    }
    //改变访问权限不构成重载
//    private int method(int a,int b){
//        return a + b;
//    }

（3）动态多态性-------------重写（override）

1. 方法的重写发生在子父类中，所以两个类必须要有继承关系

2. 子类重写父类的要求：
   ①：子类的方法的权限必须比父类方法权限要高或者相等
   ②：子类的方法必须与父类的返回值类型、方法名、参数列表相同才能构成重写

3. 即：三同一不同

public void show(){
        System.out.println("persion------>啊啊啊啊");
    }

    //重写父类的方法-------> 动态多态性
    @Override
    public void show() {
        System.out.println("Teacher------>哇哇哇哇");

    }

四、Java23种设计模式之-----------单例设计模式

（1）单例设计模式

1. 保证任何时刻一个类只能有一个实例对象
2. 私有化构造方法不允许外界创建对象，对外提供一个全局访问点获取唯一对象
3. 分为懒汉式和饿汉式
4. 为什么其属性和方法需要加静态static呢？因为这个类不能被外界new一个实例化对象，那么就需要这个类一加载就在内存中分配好属性和访问点的供外界调用此方法！用类名.方法名调用即可

（2）懒汉式

即：当调用方法时才会创建对象

class User(){
	private static User user = null;
	private User(){}
	public static User getUser(){
		if(user == null){
			 user = new User();
		}
			return user;
	}
}

（3）饿汉式

即：类一加载就创建一个对象

class User(){
	private static User user = new User();
	private User(){}
	public static User setUser(){
		return user;
	}
}