多态
- 对象具有多种形态, 对象可以存在不同的形式
- 父类指针指向子类对象
- 在方法调用时, 通过父类进行调用, 真正执行时, 调用的是子类方法, 这种特征我们称之为多态
????多态的特点
- 把子类对象赋给父类变量
- 在运行时期会表现出具体的子类特征
- 调用子类的方法
- 既然子类是一种特殊的父类
- 那么我们可不可以认为, 狗对象/猫对象就是动物类型的对象, 对象具有多种形态,对象可以存在不同的形式
Animal.java
public class Animal {
void eat() {
System.out.println("动物吃东西");
}
}Dog.java
public class Dog extends Animal {
void eat() {
System.out.println("狗吃骨头");
}
}Cat.java
public class Cat extends Animal {
void eat() {
System.out.println("猫吃鱼");
}
}没有使用多态
public class Demo {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
Cat cat = new Cat();
cat.eat();
}
}使用多态
public class Demo {
public static void main(String[] args) {
Animal dog = new Dog();
dog.eat();
Animal cat = new Cat();
cat.eat();
}
}????多态的作用
- 当把不同的子类对象都当作父类类型来看待，可以屏蔽不同子类对象之间的实现差异
- 从而写出通用的代码达到通用编程，以适应需求的不断变化
????多态方法调用问题
instanceof
- 作用：判断一个对象是否是指定的类
- 类的强制类型转换，把父类对象赋值给子类类型
- Animal类在上面的代码块中有
public class Demo {
static void feedAnimal(Animal anim) {
if (anim instanceof Dog) {
Dog dog = (Dog) anim;
dog.eat();
} else if (anim instanceof Cat) {
Cat cat = (Cat) anim;
cat.eat();
}
}
public static void main(String[] args) {
Animal dog = new Dog();
feedAnimal(dog);
Animal cat = new Cat();
feedAnimal(cat);
}
}代码块
- 在类中或方法当中使用
{}括起来的一段代码，就称它是一个代码块
代码块分类
????局部代码块
- 直接定义在方法内部的代码块，在调用方法的时候执行
????初始化代码块
- 直接在类当中定义代码块
- 初始化代码块在运行时，还是要把它放到构造方法当中
????静态代码块
- 在初始化代码块前面加上一个
static - 在加载字节码时就会自动调用
- 在主(main)方法之前执行的。只执行一次
类加载
- 当第一次创建该类对象的时候，加载到内存当中
- 在加载时，会执行static代码块中的内容
????字段初始化问题
- 静态字段初始化：是在静态代码块当中初始化
- 非静态的字段初始化：它是在构造器当中做的初始化
子类构造器默认会调用父类的构造器
SuperClass.java
public class SuperClass {
SuperClass(){
System.out.println("构造器SuperClass");
}
}SubClass.java
public class SubClass extends SuperClass {
static {
System.out.println(1);
}
SubClass(){
super();
System.out.println(2);
}
}Demo.java
public class Demo {
private static Demo demo = null;
private SubClass subClass = null;
static {
demo = new Demo();
System.out.println(3);
}
public Demo() {
subClass = new SubClass();
System.out.println(4);
}
public static void main(String[] args) {
System.out.println("main");
}
}final
- 继承弊端：破坏了我们的封装，它可去访问父类当中的实现细节，可以覆盖父类当中的方法
- final作用：修饰的内容
最终，不可修改的，保证数据的安全
????final可以修饰内容
- 字段：不能再去修改该字段的值，就变为了常量
- 方法：子类就能再去覆盖该父类的方法也就是不可以进行重写了
- 类：该类就不能再去被继承
????注意点
- final修饰字段时，字段是没有初始值，必须得要自己手动设置初始值
- final修饰变量，就代表是一个常量，
命令规则：所有的字母都大写例如：MAX_VALUE - final可以在局部代码块当中使用
- 如果final修饰的是基本数据类型，代表值不能再去修改了
- 如果final修饰的是一个引用类型，代表对象引用的地址不能再去修改
单例设计模式
设计模式就是之前很多程序员经常无数次的尝试，总结出来一套最佳实践(方案)
单例：一个类在内存当中只有一个对象。别人不能再去创建新的对象
饿汉模式
- 必须得要在该类中创建一个对象出来
- 私有化自己的构造器。防止外界通过构造器来创建新的对象
- 给外界提供一个方法，能够获取已经创建好的对象
class ToolUtil {
private static ToolUtil instance = new ToolUtil();
private ToolUtil() {
}
static public ToolUtil getInstance() {
return instance;
}
}懒汉模式
- 就是一开始不创建需要的时候在创建
- 但是有一个问题就是
线程不安全问题 - 懒汉模式就是先不知道需不需要，等到需要的时候在创建一个，下次就不会在创建了就使用第一次创建好的
class ToolUtil {
private static ToolUtil instance = null;
private ToolUtil() {
}
static public ToolUtil getInstance() {
if (null == instance) {
instance = new ToolUtil();
}
return instance;
}
}
