[Java知识库]java小白训练营day06-面向对象：封装+继承+多态

面向过程和面向对象

需求：把大象装到冰箱
1）面向过程：（简单）
第一步：把冰箱门打开
第二步：把大象装入冰箱
第三步：把冰箱门关闭
关注：怎么把问题解决步骤，然后按步骤顺序一步步实现
2）面向对象：（复杂）
实体POJO：（名词）
大象（特征-属性（大鼻子、粗腿、细尾巴、蒲扇耳朵），行为-方法（吃、玩、迁移））、
冰箱（特征（容量、电、冷藏和冷冻，门），行为（加电和断电、打开和关闭门））
打开冰箱，把大象装入，关闭冰箱门
关注：实体建模

面向过程它急于去实现细节，往往考虑细节不够周到（开发者、用户）；
如果考虑不周，会造成项目无法按时交付，甚至推到重来。
先松后紧

面向对象它干活不急，它在构建对象（建模），所有的细节都考虑了。
甚至有些用户没有提出的需求它都考虑到了。

需求变更。

需求：我到超市买吃的，买了5样东西。又买了锅。
1、面向过程，我到超市；买东西，交付5样钱。（改代码）C语言
2、面向对象，把超市的所有的商品1000都建模。（不用改代码）java语言、python语言
考验设计这能力，面向对象设计比面向过程设计要难。

面向对象的三大特性

封装：把对象细节隐藏起来，调用者使用时就变的简单。
汽车，拆盲盒
继承：和生活中继承类似，它能从继承中获取“利益”。
多态：一个东西，在不同情况下，表现出不同特性。
水（液态），零下-273度，（固态）

封装 POJO有特殊要求

1）所有属性不能直接对外访问，修改访问修饰符，私有 private
2）对这个属性name，给它两个方法：getName 获取name值，setName 设置name值

package cn.tedu.oop.pojo;

//POJO（Plain Ordinary Java Object）简单的Java对象
public class Person {
	//一堆私有属性（字段）
	private String name;
	private String sex;
	private Integer age;
	private String school;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
	//一堆对应每个属性get和set方法，eclipse都自动生成
	
	
}

package cn.tedu.oop.pojo;

//POJO（Plain Ordinary Java Object）简单的Java对象
public class Person {
	//一堆私有属性（字段）
	private String name;
	private String sex;
	private Integer age;
	private String school;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
	//不属于标准POJO要求，但是日常为了测试方便
	//@Override //注解，重写，重写父类相同方法，继承Object类
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + ", school=" + school + "]";
	}
	
	//一堆对应每个属性get和set方法，eclipse都自动生成
}

继承

在java中所有创建类都是Object子类（继承）
直接继承（父）和间接继承（爷，多级）
java中只是单继承，不允许多继承，不允许有两个父亲；c++语言就支持多继承。菱形继承

包装类型，使用了直接继承和间接继承（单继承，多级）

package test;

import org.junit.Test;

//找典型包装类：整型、浮点、字符、布尔
public class TestWrapper {
	@Test
	public void wrapper() {
		System.out.println( "整型本类:"+ this.getClass().getName());
		System.out.println( "整型父类:"+ this.getClass().getSuperclass());
		System.out.println( "整型爷类:"+ this.getClass().getSuperclass().getSuperclass());
		System.out.println();
				
		Integer i = 10;
		System.out.println("整型父类:"+ i.getClass().getSuperclass() );
		System.out.println("整型爷类:"+ i.getClass().getSuperclass().getSuperclass() );
		System.out.println("整型宗族:"+ i.getClass().getSuperclass().getSuperclass().getSuperclass() );
		System.out.println();
		
		Double d = 10.0;
		System.out.println("浮点父类：" + d.getClass().getSuperclass());
		System.out.println();
		
		Character c = 'a';
		System.out.println("字符父类：" + c.getClass().getSuperclass());
		System.out.println();
		
		Boolean b = true;
		System.out.println("布尔父类：" + b.getClass().getSuperclass());
	}
}

需求：车，宝马车BWCar，劳斯莱斯幻影HYCar

1）属性：名字name、价格price、颜色color
2）方法：run（）
分析：
1）公用属性和方法提取到一个新类中Car，这些信息就从本类（子类）中删除
2）必须使用继承类方式：extends Car，标明继承关系
优点就是：代码复用。

package cn.tedu.oop.pojo;

public class Car {
	private String name;
	private Double price;
	private String color;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	@Override
	public String toString() {
		return "Car [name=" + name + ", price=" + price + ", color=" + color + "]";
	}
}

package cn.tedu.oop.pojo;

//复用
public class BWCar extends Car{
	public void runBW() {
		System.out.println("宝马");
	}
}

package cn.tedu.oop.pojo;

//标明继承关系
public class HYCar extends Car{
	
	public void runHY() {
		System.out.println("幻影");
	}
	
}

package test;

import org.junit.Test;

import cn.tedu.oop.pojo.BWCar;
import cn.tedu.oop.pojo.HYCar;

public class TestCar {
	@Test
	public void car() {
		BWCar bw = new BWCar();
		bw.setName("宝马7系");
		bw.setPrice(40.0);
		bw.setColor("红色");
		
		System.out.println(bw);
		bw.runBW();
		
		HYCar hy = new HYCar();
		hy.setName("劳斯莱斯幻影");
		hy.setPrice(100.0);
		hy.setColor("黑色");
		
		System.out.println(hy);
		hy.runHY();
	}
}

多态

同一个类，但是在不同情况下，展现结果不同的
多态其中最典型接口和实现类
需求：老虎和鹰，都有名字 name（属性），都可以吃肉肉 eat，run（跑的快，飞的高）（方法）
1）接口：动物 Animal (它是一个特殊类，没有实现，实现类（子类）去实现）
2）实现类：老虎 Tiger、鹰 Eagle

package cn.tedu.oop.pojo;

//接口，特点，它没有实现方法
public interface Animal {	
	public void run();	//抽象方法的声明（定义）
}

package cn.tedu.oop.pojo;

//要把实现类实现具体接口
//extends跟类，implements跟接口
//实现接口，必须实现接口中定义所有的方法
public class Tiger implements Animal{

	@Override //重写接口中方法
	public void run() {
		System.out.println("老虎吃肉肉");
	}

}

package cn.tedu.oop.pojo;

//实现类
public class Eagle implements Animal{

	@Override
	public void run() {
		System.out.println("老鹰飞的高");
	}

}

package cn.tedu.oop.pojo;

public class Cat implements Animal{

	@Override
	public void run() {
		System.out.println("猫抓老鼠");
	}

}

package test;

import org.junit.Test;

import cn.tedu.oop.pojo.Animal;
import cn.tedu.oop.pojo.Cat;
import cn.tedu.oop.pojo.Eagle;
import cn.tedu.oop.pojo.Tiger;

public class TestAnimal {
	@Test
	public void animal() {
		//接口 实例名称 = new 实现类();
		Animal tiger = new Tiger();
		tiger.run();
		
		Animal eagle = new Eagle();
		eagle.run();
		//? 多态体现在哪里，同一个Animal对象，同一个run方法，但是结果不一样
		//？这样做有什么好处，接口好处，如果有新的类，只改变少量代码即可实现
		Animal cat = new Cat();
		cat.run();
	}
}