【JavaOOP】4、向上转型与向下转型、final与static关键字、单例设计模式

7. 向上转型与向下转型

7.1 向上转型

父类的引用指向子类

优点： 增强了程序的扩展性。
缺点： 不能调用子类有父类没有的方法。

/**
 * 向上转型：父类的引用指向子类 (开发中经常使用)
 * 核心：父类和子类有相同的方法时，调用的是子类的方法！
 * 问题：当子类有的方法而父类没有，此时这种就不能解决这个问题。
 */
@Test
public void test01(){
    Person person = new Employee();
    person.sayHello();
}

7.2 向下转型

把父类引用强制转换为子类对象

优点： 可以调用子类有父类没有的方法。
缺点： 不能增强程序的扩展性。

/**
 * 向下转型：解决的是父类没有而子类有的方法的调用问题
 *（开发中不经常使用）
 */
@Test
public void test02(){
    Person person = new Employee();
    ((Employee) person).welcome();
}

7.3 小结

1、向上转型： 调用的方法必须在父类中存在，子类中如果没有则调用父类的方法，子类中如果存在则调用子类的（此时子类重写了父类的方法）。
2、向下转型： 如果调用的方法只存在子类中，父类中没有此方法则需要进行类型转换，即将原来的父类对象转换为现在的子类对象，这就是所谓的向下转型。

8. final 与 static 关键字

8.1 final 关键字

1、由final修饰的类不能被继承。
2、由final修饰的字段只能是常量，常量字段必须要赋初始值，否则会报错，常量不能被修改。
3、由final修饰的方法不能被重写

8.2 static 关键字

1、由static的修饰的方法不能调用成员方法（非static）的方法。
2、成员方法可以调用静态方法。
3、由static修饰的属性或方法属于对象级别的全局变量。
4、静态成员，可以使用类或对象进行访问，建议使用类名访问！

public class Student extends Person {    
	public void sayHello() {
        hello();
        System.out.println("Student: sayHello()");
    }

    public static void hello(){
        System.out.println("hello....");
        // 错误：原因是静态的方法先于非静态方法分配内存空间并初始化。
        // sayHello();              
    }
}

    @Test
    public void test03(){
        Student st = new Student();

        // 静态成员，可以使用类或对象进行访问，建议使用类名访问！
        Student.hello();
        st.hello();
    }

8.3 类的初始化时机

1、Java中的成员变量或成员方法，属于对象所拥有，在使用new构造一个对象时，才会为其分配内存空间，并且成员方法一定会在成员属性之后分配空间。
2、Java中的非成员变量或非成员方法，又叫类成员或静态成员，属于类所拥有，当我们定义一个类时，就会为类成员分类内存空间，并且类方法会在类变量之后分配空间。
3、静态方法只能访问静态的变量或方法，而非静态的方法能够访问静态或非静态的方法或属性。
4、static修饰的属性或方法，叫静态属性或静态方法。可以理解为静态的属性或方法实际上就是对象级别的全局变量，即静态属性或方法是每个对象所拥有的。
5、一般情况下，访问静态的方法或属性时，使用类名来访问，虽然可以使用对象来访问，但不推荐。

9. 单例设计模式

9.1 懒汉式

//第一种方案: 懒汉式
// 1.1 定义一个私有的静态的对象
private static User user = null;
// 1.2 定义一个私有的构造方法
private User(){
}
// 1.3 定义一个公有的静态方法，用来获取对象
public static User getInstance(){
    if(user == null){
        user = new User();
    }
    return user;
}

/**
 * 1. 测试单例-懒汉式
 */
@Test
public void test01(){
    User user1 = User.getInstance();
    User user2 = User.getInstance();
    System.out.println("user1 = " + user1);
    System.out.println("user2 = " + user2);
}

程序运行结果为：

9.2 饿汉式

//第二种方案：饿汉式
// 2.1 定义一个私有的静态的对象
private static User user = new User();
// 2.2 定义一个私有的构造方法
private User(){
}
// 2.3 定义一个公有的静态方法，用来获取对象
public static User getInstance(){
    return user;
}

/**
 * 2. 测试单例-饿汉式
 */
@Test
public void test02(){
    User user1 = User.getInstance();
    User user2 = User.getInstance();
    System.out.println("user1 = " + user1);
    System.out.println("user2 = " + user2);
}

程序运行结果为：