折纸的不归路(10)

一.多态

在同一领域内的两个事物的对象，实现同一个操作，产生不同的结果的现象叫多态。

1、一定发生继承关系中（目前）
cat和dog 都继承了animal
2、一定重写了父类中的同一个方法
animal中有一个display方法
cat和dog都重写了display
3、一定是父类的引用指向了子类的对象

多态中参数具有向上传递的功能
C和D继承自B
B继承自A

顺序：
this.show(o);
super.show(o);
this.show(super(o));
super.show(super(o));

引用类型的数据类型转换：
应该有一个大小关系的转换
子父类
Animal a = new Animal();
Cat c = (Cat)a;
Dog d = new Dog;
Animal a = d;

instanceof：
语法： 对象 instanceof 类/接口
判断：左侧对象是不是属于右侧类（目前）

关于多态的代码表示

package day08;

public class A {
	public String show(A a) {
		return "A and A";
	}
	public String show(D d) {
		return "A and D";
	}
//	public String show(B b) {
//		return "A and B";
//	}
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b1 = new B();
		B b2 = new C();
		B b3 = new D();
		C c = new C();
		B d = new D();
		A c1 = new B();
//		System.out.println(b1.show(c));
//		System.out.println(b1.show(d));
//		System.out.println(a2.show(c));
//		System.out.println(a2.show(d));
		System.out.println(a1.show(c1));
//		System.out.println(a1.show(b3));
	}
}

class B extends A{
	public String show(B b) {
		return "B and B";
	}
	//如果把showB注释掉,再向A中加一个showB
	//执行b1.show(c)时先向B中寻找show(c),没有,然后去父类A中找show(c),没有
	//再从B中找show(c)的父类show(b),此时已经备注释,没有,最后再去父类A中找show(c)
	//的父类show(b)找到了,执行,输出结果"A and B"
	public String show(A a) {
		return "B and A";
	}
}

class C extends B{
	
}

class D extends B{
	
}

====================================================

二.修饰符

static ：用来声明是否是静态的
static能够放在哪些位置？(变量前面)
修饰变量：静态变量
静态变量被所有对象共享，场景：两个对象同时操纵同一块数据
例:
两个工人修路，肯定不是一人修一条路，两个人合修一条路
路长100米
第一个工人修了20m
第二个工人修了10m
路还剩70米

实例变量属于各对象，互不干扰
修饰方法：静态方法
静态方法要通过类名.方法名();进行调用
实例方法要通过对象.方法名();进行调用
静态方法中不允许出现非静态的变量
实例方法中可以出现静态变量

修饰代码块：静态代码块
静态代码块在程序执行的时候只能执行一次
静态代码块的执行优先级最高
静态代码块中只能出现静态变量和静态方法的调用
场景：需要一个数组来不断的接收添加的数据，在静态代码块中初始化数组
代码块执行的优先级要早于构造器
总结：静态成员是依赖于类的
非静态成员是依赖于对象的
如何让对象只有一个？
单例模式 —>接触的最简单的也是最早的设计模式
在程序执行阶段，有且只有一个对象（产生的所有对象的地址相同）。
步骤：
1、将构造器变为私有的，让外界不可以new的方式创建对象
2、提供获得对象的接口（定义一个静态方法来返回对象）
3、提供一个静态变量，单例的对象用来返回
根据new对象的时机不同，将单例模式有懒汉式和饿汉式两种类型

手动写一个单例模式

package day08;
/**
 * 这是一个单例类
 * 用来生成单例对象
 * @author Acer
 *
 */
public class Single {
	//准备一个single的静态变量
	private static Single single;
	//构造器声明为私有的
	private Single() {
		
		
	}
	//提供一个获得对象的接口
	//提供静态方法
	public static Single getINstance() {
		if(single == null) {
			single = new Single();
		}//懒汉式
		return single;
	}
	public static void main(String[] args) {
		Single single= new Single();
	}
}

创建一个类来进行单例模式测试:

package day08;

public class SingleTest {
	public static void main(String[] args) {
//		Single s1 = new Single();
//		Single s2 = new Single();
		Single s1 = Single.getINstance();
		Single s2 = Single.getINstance();
		System.out.println(s1);
		System.out.println(s2);
	}
}

可以得到输出结果为

day08.Single@15db9742
day08.Single@15db9742

得出两个对象的地址相同

对象和对象之间的关系：
继承
组合关系：随着另一个对象的消失而消失
聚合关系：不会随着另一个对象的消失而消失，相互独立的，但是共同组成了一个子系统

三.心得

今天在多态的相关方面再次绕了进去,逻辑关系还是有点混乱,还得多看看老师讲的,再深入理解理解.