面向对象 4 super 多态 引用数据类型转换 final 单列模式

1. super

1. super的引入：提出疑问

类的设计

a)设计一个用户类User : 包含：   用户名  密码 字段

b)让学生类和老师类继承 User用户类

4)规范写法：User类中的用户名及密码字段应该私有化提供get set方法

问题：父类User中的字段私有化,子类学生类和老师类能够继承到用户名和密码吗?

a.从目前理解(主要是从访问权限来看),子类是继承不到私有成员的;

b.是否应该在子类中再定义用户名和密码字段呢?    不应该!

c.结论：子类对象中应该没有用户字段及密码字段可以存值

1. super概念+比较this

1.super在子类中，代表父类的对象

2.this持有当前对象的地址值，虽然super在子类中代表父类的对象，但是不持有父类对象的地址值

1. super的使用场景

super的使用场景：

前提：子类中能够访问的父类的成员，权限相关

1.区分子类字段与父类字段的二义性

2.访问父类的成员，前提有权限

3.可以在子类的构造方法的第一句，调用父类的构造方法

1. super的特殊用途及分析

特殊场景：

1.如果在子类的构造方法中，没有显示的写出对于父类构造方法的使用，

默认会调用父类的无参数的构造方法

如果写出了对于父类构造方法的使用，那么默认的调用就不存在了

 

结论：无论如何子类的构造方法，都会用到父类的构造方法

 

1. 多态【重要】

1. 多态的概念

官方概念：编译时跟运行时类型不一致就产生了多态

民间理解：父类类型的变量，存放子类类型的对象，可能存放子类类型的对象有多种可能

多态存在的前提：必须有继承关系

1. 多态的编译时运行时过程

1.编译时，看的是父类类型，会现在父类中，看有不有对应的方法，如果没有继续向上找{更高父类}

  如果找到了，编译通过，如果找不到，编译失败报错

2.运行时：看真实类型，如果在真实类型中找到了，就运行真实类型中的函数，如果没有找到，向上找

1. 多态的应用示例

 

class _06DuoTai{

public static void main(String[] args){

XDog xdog = new XDog();

DDog ddog = new DDog();

Person per = new Person();

//传入 要喂的 xdog对象

per.feedDog(xdog);

//传入 要喂的 xdog对象

per.feedDog(ddog);

}

}

class Person{

//多态  ， 不管你喂什么狗 你传一个狗类型进来  就是喂 这类型的狗。

void feedDog(Dog dog){

dog.eat();

}

 

}

class Dog{//父类

void eat(){

System.out.println("吃肉肉..");

}

}

class XDog extends Dog{//子类

void eat(){//覆写 子类根据自己需求 复制父类方法 然后改写父类方法

System.out.println("吃小粑粑..");

}

}

class DDog extends Dog{//子类

void eat(){//覆写  子类 根据自己需求 复制父类方法 然后改写父类方法

System.out.println("吃大粑粑..");

}

}

 

 

1. 引用数据类型转换

1. 为什么需要数据类型转换

为什么需要数据类型转换呢？

1.继承关系：父类提取的是共性:明白，子类是有自己特性的

2.开发中，我们采用了多态的写法，出现问题：编译只看类型

 

3.怎么解决呢？

还原真实类型【Animal类型变成CoffeCat】数据类型的转换

1. 数据类型转换的两种情况

引用【数据类型】转换的几种情况

1.小转大【自动类型转换】：子类类型转换成父类类型

  Animal aml = new CoffeCat();

2.大转小【强制类型转换】：父类类型转换成子类类型

  数据类型 变量名 = (数据类型)值;

1. 数据类型转换的注意事项

在类型转换之前应该要[先判断类型]，确保类型正确，再做转换

 

 

 

 

 

1. final

1. final概念

final  :  Java中的一个关键字,修饰符：表示的意思：最终的,不可变的，不可拓展的！

1. final可修饰内容的测试

1.外部类：可以

2.普通方法：可以

3.成员字段：可以

4.局部变量：可以

5.内部类：可以 [ 暂时不学 ]

6.构造方法：不可以

1. final修饰内容的效果

1.可以修饰类：最终类：太监类，没儿子

2.可以修饰变量：不可变的：

变量这个容器：如果装了值，用final修饰了，不能改变值

一般是和public static final 一起使用：常量

public static final double PI = 3.14;

3.可以修饰普通方法:不能拓展

final修饰的方法不能覆写

 

static修饰的方法不能覆写

 

private修饰的方法不能覆写

 

 

 

1. final测试

class _12FinalDemo{

public static void main(String[] args){

//final 修饰的是stu变量，不是修饰的 name字段 所以是可以改的

final Student stu = new Student("小明",18);

stu.name = "大明";

System.out.println(stu);

 

//stu = new Student("大明",18);//_12FinalDemo.java:14: 错误: 无法为最终变量stu分配值

}

}

class Student{

String name;

int age;

Student(String name,int age){

this.name = name;

this.age = age;

}

public String toString(){

return this.name+"---"+this.age;

}

}

 

1. 单例模式

1. 单例模式的概念

需要设计一个类，达到的效果： 此类在整个应用中只存在一个对象

1. 饿汉模式分析实现

1.单例模式之恶汉模式实现

1.随便new就是对象怎么处理？私有化构造方法

2.A instance = new A(); 内部对象了：但是不能用  static

3.static A instance = new A();

A.instance = null; 别人能修改

4.final static A instance = new A();//2字段 不好！

5.instance 字段 private  提供get[set]

6.提供获得的方法getInstance

2.为什么要叫做恶汉：不管你用还是不用A对象，都先给你创建一个出来

1.计算机启动：有些软件不用，开机就启动，系统的效率

2.启动软件的时候：恶汉模式有些对象都不用，都直接启动创建，软件启动的效率会降低

3.好处：线程安全

1. 懒汉模式分析实现

1.设计实现之懒汉模式

1)明确：应用程序在第一次调用方法获取单利模式对象的时候创建对象

2)构造方法私有化

3)设置一个A类类型的字段私有化不初始化值

4)提供一个方法允许外部使用该方法访问该字段

5)外部不能创建对象，所以方法必须static修饰

6)什么时候是第一次【instance == null】

7)当第一调用的时候判断

a.如果instance == null ：初始化instance

b.如果instance != null : 直接返回instance

1. 懒汉模式线程安全分析

懒汉模式直接用线程是不安全的，要做if语句加一把锁

转载于:https://my.oschina.net/u/4083693/blog/3026660