javaSE基础面向对象笔记（4）多态，向上转型，设计模式

1.多态
一个事物具有多种表现形态
1.重载：同一个类中 方法名相同 参数列表不同 多态的一种表现
2.重写：在继承关系中，子类重写父类的方法 方法名和参数列表和父类的相同 多态的一种表现
多态：
编译时多态：在编译时期就可以发现的多态 重载
运行时多态：在运行时期才能发现的多态 重写
运行时多态有一个前提条件 在继承关系中
向上转型 :父类的对象名指向了子类的实体
作用:减少重复代码 提高代码的复用性 可维护性 提高可拓展性
只有在运行时知道是哪个类的对象的时候才能知道调用的是否是重写以后的方法

public class Animal {
	public void eat() {
		System.out.println("吃");
	}
	public void sleep() {
		System.out.println("睡");
	}
}
public class Cat extends Animal{
	@Override
	public void eat() {		
		System.out.println("猫吃鱼");
	}
	@Override
	public void sleep() {		
	System.out.println("猫睡觉");
	}
}
public class Test {
	public static void main(String[] args) {
		Cat cat = new Cat();
		show(cat);		
		//匿名对象没有名字 只能调用一次属性或方法
		new Cat().eat();
		new Cat().sleep();	
		show(new Cat());//匿名对象的写法			
		Animal animal = new Cat();
		animal.eat();
		animal.sleep();
}
	public static void show(Animal animal) {
		animal.eat();
		animal.sleep();
	}
	public static void show(Cat cat) {
		cat.eat();
		cat.sleep();
	}
}

2.向上转型
向下转型:向上转型以后,对象无法调用子类特有的方法,为了杜绝这个问题向下转型
前提:先向上转型了
凡是向下转型之前都要进行判断instanceof

public class Person {
	public void oprea() {
		System.out.println("唱戏");
	}
}
public class Son extends Person{
	public void showjava() {
		System.out.println("展示敲代码");
	}
}
public class SecondSon extends Person{
	public void studyRY() {
		System.out.println("学习日语");
	}
}
public class Test2 {
	public static void main(String[] args) {
		//向上转型
		Person father = new Son();
		father.oprea();	
		Son son = (Son) father;
		son.showjava();	
		Person person = new SecondSon();
		person.oprea();
		//向下转型
		SecondSon secondSon = (SecondSon) person;
		secondSon.studyRY();
		//father是否是secondSon类创建出来的 是则为true
		if(person instanceof SecondSon) {
			SecondSon secondSon2 = (SecondSon) person;
			secondSon.studyRY();
		}else {
			System.out.println("错误");
		}
	}
}

3.设计模式
设计模式 23种
起源： 建筑行业 -->
设计模式：并不是在任意场景都可以使用， 也并不是效率极其高。
只是在特定问题的特定解决方案

1. 单例设计模式
   单例 实例 对象 --> 一个类只能创建一个对象
   减少内存消耗 ， 减少资源消耗
   减少状态混淆
   两种实现方式：
   饿汉式
   懒汉式
   实现单例思路：
   饿汉式：
   1.私有化构造方法
   2.创建用private static 和 final修饰的对象
   3.添加static修饰的 静态get方法，
   懒汉式：
   1.私有化构造方法
   2.添加private static 的属性，赋值为null
   3. 添加static的静态get方法
   4. 在方法中判断是否是第一次调用，如果是则创建，否则直接返回对象
   懒汉式线程不安全
   饿汉式是线程安全的
2. 简单工厂设计模式
   懒汉式设计模式

public class LazyInstance {
	//1.私有化构造方法
	private LazyInstance() {		
	}
	//2.添加属性
	private static LazyInstance instance = null;	
	//3.添加get方法
	public static LazyInstance getInstance() {
		if(instance == null) {
			instance = new LazyInstance();
		}
		return instance;
	}
}
public class Person {
	private Person() {		
	}
	//本类创建一个对象
	private static final Person person = new Person();
	//提供get方法供外界使用
	public static Person getInstance() {
		return person;		
	}
}
public class Test {
	public static void main(String[] args) {
		Person person1 = Person.getInstance();
		Person person2 = Person.getInstance();
		Person person3 = Person.getInstance();
		System.out.println(person1);
		System.out.println(person2);
		System.out.println(person3);		
		LazyInstance instance = LazyInstance.getInstance();
		LazyInstance instance2 = LazyInstance.getInstance();
		LazyInstance instance3 = LazyInstance.getInstance();
		System.out.println(instance);
		System.out.println(instance2);
		System.out.println(instance3);
	}
}

4.简单工厂设计模式
将逻辑结构细节封装到了工厂中 用户只需要调用

public class Clothes {
	public void perpare() {
		System.out.println("准备工作");
	}
	public void make() {
		System.out.println("制作");
	}
	public void box() {
		System.out.println("打包");
	}
}
public class Shoes extends Clothes{
	@Override
	public void make() {		
	System.out.println("制作鞋子");
	}
}
public class Paints extends Clothes{
	@Override
	public void make() {		
		System.out.println("制作裤子");
	}
}
public class Jacket extends Clothes{
	@Override
	public void make() {		
		System.out.println("制作夹克");
	}
}
public class Facotry {
	public static Clothes getClothes(String type) {
		if("裤子".equals(type)) {
			return new Paints();
		}else if ("上衣".equals(type)) {
			return new Jacket();
		}else {
			return new Shoes();
		}
	}
}
public class Test {
	public static void main(String[] args) {
		//1.工厂对象
		//2.给工厂对象传递一个
		//3.返回裤子对象
		Clothes clothes = Facotry.getClothes("鞋子");
		clothes.make();		
		Shoes shoes = (Shoes) clothes;
		shoes.make();	
		Shoes shoes2 = new Shoes();
	}
}