java小白训练营day06-OOP：面向对象+封装+继承+多态

面向对象

是一种编程思想，编写程序时如何下手，怎么去解决实际问题。

面向过程和面向对象的区别？

OPP Procedure Oriented Programming 早期编程是思想推崇面向过程的思考（c语言、pascal语言）
OOP Object Oriented Programming 现今主流的编程思想推崇面向对象的思考（c++、java、python、c#）

案例：把大象装入冰箱

面向过程的思考方式：
把一个大的问题拆分成多个小问题，按步骤完成。
步骤：
1）把冰箱门打开
2）把大象放入
3）把冰箱门关上
面向过程的思考，关注处理问题的过程。

面向对象的思考方式：
1）找对象（实体、名词）大象和冰箱
2）分析大象的特质（大耳朵，小尾巴，粗腿）和行为（走，扇耳朵），分析冰箱的特质（容量、温度）和行为（开门、关门）
3）把冰箱门打开，把大象放入，把冰箱门关上

面向过程和面向对象的思考问题方式不同，面向过程关注过程，步骤；面向对象关注实体（对象）对象行为

案例：我周日去超市买葡萄、水饺

面向对象方式思考：
1）找实体（名称）
创建所有的商品的实例-建模（建立模型）（葡萄、水饺、面包、小青菜、菠菜、豆腐。。。。500种）
2）具体买葡萄、水饺

面向对象非常麻烦，它要花大量时间去构建目前来说无用的实体
这样做有什么意义呢？

需求变了，老婆说了，她想吃椰蓉面包
此时面向过程是无法适应的，它之前只关心之前的需要中的内容，只有葡萄、水饺，没有面包。怎么解决？重新设计。
面向对象，之前已经对“面包”进行了建模。这时面向对象的优点就体现了，需要变化了。但是我们只需少量改动即可使用。

面向过程的思考，速度快，更加贴近实际开发。（按需而动）
面向对象的思考，速度慢，构建对象是（实体）想的多想的全，当需求发生变化（需求变更），面向过程就需要改大量的代码，甚至推到重来。工作量巨大，时间没了。面向对象需求变更就小（设计者能力）（按事务发展经验之谈）

实际中开设按面向对象设计，然后按面向过程的设计。这样不是设计过度。两种设计思想相结合。

面向对象的三大特征

封装、继承、多态

封装 encapsulation

隐藏对象的细节
案例：手机
我们不知道手机是如何工作的，它如何去拨打电话就能和别人连线，如果把点信号转换成声音呢？。。。这些细节我们都不知道，但我们照样可以使用手机。
怎么拨号，怎么上网wifi
这些细节都被包装起来，而这些包装的内容对于使用者不用知道。它关心怎么拨号，怎么上wifi，聊微信，聊QQ
封装就是把用户不需要关心的内容进行隐藏，这有什么好处呢？用户关心的内容越少越好，使用起来就越方便。

案例：开车
你懂发动机吗？你懂轮胎型号吗？你懂加油有什么要注意的吗？
都不懂，只懂开车，方向盘，油门，刹车。

java语言中如何体现封装

1）把类的属性（特质、特征）变成私有，不允许直接访问 private 私有
Phone phone = new Phone();
phone.key 按钮，
phone.call() 拨打电话
2）设置get 获取和set方法 设置

不标准的写法

package cn.tedu.entity;
//entiy 就叫实体

/*
 * 创建一个类Phone，体现封装
 * 1）私有属性
 * 2）对应get和set放
 * 私有属性不允许外界直接访问，只能通过对应get和set方法访问
 */
public class Phone {
	public String key;	//按键
	
	//在类中利用main方法进行测试
	public static void main(String[] args) {
		//创建对象实例，才可以调用它的属性
		Phone phone = new Phone(); //创建对象
		phone.key = "136";
		System.out.println(phone.key);
	}
}

package cn.tedu.entity;

/*
 * 体现java中封装，
 * 私有key不允许直接访问（隐藏）
 * 只能通过get和set方法进行操作
 */
public class Phone {
	private String key;
	//自动产生get和set方法，里面会有this，含义

	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		//this代表当前对象，this.key代表属性，key代表参数
		this.key = key;
	}
}

package test;

import cn.tedu.entity.Phone;

public class TestPhone {
	public static void main(String[] args) {
		//1.创建实例
		Phone phone = new Phone();
		
		//2.调用set方法设置值
		phone.setKey("188");
		
		//3.调用get方法获取，打印
		System.out.println( phone.getKey() );
	}
}

package cn.tedu.entity;

import java.util.Date; //必须选择util包下的，不能选择sql包下的，否则报错

public class Person {
	//私有属性（字段）都习惯使用包装类型
	private String name;
	private Integer age;
	private Date birthday;	//日期类型
	private String address;
	
	//产生它的gets/sets方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	
	@Override //重写，重新父类Object.toString方法
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", birthday=" + birthday + ", address=" + address + "]";
	}
}

package test;

import java.util.Date;

import cn.tedu.entity.Person;

public class TestPerson {
	public static void main(String[] args) {
		//1.创建对象
		Person person = new Person();

		//2.设置值，初始化，设置是没有顺序的（自由）
		person.setName("陈晨");
		person.setAge(12);
		person.setBirthday(new Date());  //当前日期
		person.setAddress("北京中关村");
		
		//3.访问，打印。覆盖它的toString() 自动产生
		System.out.println(person.toString());
	}
}

继承 inheritance

c语言的继承非常强大，它支持多继承（爸、妈。。。）有风险，非常难控制，继承层级过多后，非常难知道继承来自谁
java语言简化c语言，不支持多继承，只支持单继承。安全。

java中继承的类，称为超类superClass()，也称为父类，有时叫基类。
它虽然不支持多继承，但是支持多级继承，多重继承。B继承A，C继承B，也就是说C间接继承A
爸继承了爷财产，我继承爸财产，也就是说，我最终继承了爷爷财产

java有两种继承方式

父类（类 class）使用 extends 关键字（继承）
父类（接口 interface） 使用 implements 关键字（实现）

继承的语法

package cn.tedu.entity;

//代表父类
public class Dad {
	private Double money = 100.0;  //遗产

	public Double getMoney() {
		return money;
	}
	public void setMoney(Double money) {
		this.money = money;
	}
}

package test;

import cn.tedu.entity.Son;

public class TestSon {
	public static void main(String[] args) {
		//需求：看儿子有多少钱？
		//1.创建子类
		Son son = new Son();
		
		//2.通过子类去调用父类方法
		//子类没有，就去访问父类的方法
		System.out.println(son.getMoney());
	}
}

没有继承代码怎么写？

需求：动物类，老虎 tiger（吃eat()、跑run()），鹰 eagle（吃eat()、飞fly()）
类有共性eat()，个性，tiger.run()跑、eagle.fly()飞
怎么在java中体现上面的内容。

package cn.tedu.entity;

//老虎类
public class Tiger {
	//共有的方法
	public void eat() {
		System.out.println("吃肉肉");
	}
	
	//个性的方法
	public void run() {
		System.out.println("陆地之王，跑的快");
	}
}

package cn.tedu.entity;

//老鹰类
public class Eagle {
	//共有的方法
	public void eat() {
		System.out.println("吃肉肉");
	}
	
	//个性的方法
	public void fly() {
		System.out.println("天空之王，飞的高");
	}
}

没有使用继承时，代码有冗余，每个类中都有这部分公用的代码，如果代码需要修改，就被迫得修改多处。
它的缺点。
可以使用继承来修改它，改造它！
1）创建父类，公用的代码写 Animal动物类，eat()
2）使用extends继承，去掉重复代码 Tiger extends Animal，Eagle extends Animal。子类可以调用父类的方法

父类的方式

package cn.tedu.entity;

//把老虎和老鹰共性的内容提取到这个类中
public class Animal {
	//共有的方法
	public void eat() {
		System.out.println("吃肉肉");
	}
}

package cn.tedu.entity;

//老虎类，继承父类，动物类
public class Tiger extends Animal{
	//个性的方法
	public void run() {
		System.out.println("陆地之王，跑的快");
	}
}

package cn.tedu.entity;

//老鹰类，继承父类，动物类
public class Eagle extends Animal{
	//个性的方法
	public void fly() {
		System.out.println("天空之王，飞的高");
	}
}

package test;

import cn.tedu.entity.Eagle;
import cn.tedu.entity.Tiger;

public class TestAnimal {
	public static void main(String[] args) {
		//老虎类
		//1.创建对象
		Tiger tiger = new Tiger();
		
		//2.调用对象共性和个性方法
		tiger.eat(); 	//继承父类方法
		tiger.run(); 	//本类个性方法
		
		//老鹰类
		Eagle eagle = new Eagle();
		eagle.eat();	//继承父类方法
		eagle.fly();	//本类个性方法
	}
}

接口方式继承

package cn.tedu.entity;

//水果类，它是一个接口
/*
 * 接口和实现类它不同的地方，实现类中是有实现代码的eat()方法
 * 但是接口中没有，它只有方法的定义，没有方法的实现
 * 也就是说，接口只用来规范你要有什么方法，但是方法子类去具体实现
 */
public interface IFruit {
	public void eat();	//只有放到的定义（声明），没有实现
}

package cn.tedu.entity;

//接口的实现类
//它要实现接口的所有的方法和自己个性方法
public class AppleImpl implements IFruit{

	@Override //重写接口的方法，实现接口的方法
	public void eat() {
		System.out.println("水果可以吃");
	}
	
	//个性方法自己加
	public void cut() {	//削皮
		System.out.println("苹果削皮");
	}
}

package cn.tedu.entity;

//实现类，实现水果接口
public class BeanImpl implements IFruit{

	@Override //实现接口定义方法
	public void eat() {
		System.out.println("吃豆豆");
	}
	
	public void grow() { //添加个性的方法
		System.out.println("种豆豆");
	}
}

package test;

import cn.tedu.entity.AppleImpl;
import cn.tedu.entity.BeanImpl;
import cn.tedu.entity.IFruit;

public class TestFruit {
	public static void main(String[] args) {
		//1、创建对象：接口 实例名=new 子类();
		//AppleImpl apple = new AppleImpl();
		//只能调用接口中声明的方法
		IFruit apple = new AppleImpl();
		
		//2、调用
		apple.eat();
		
		IFruit bean = new BeanImpl();
		bean.eat();
	}
}

两种继承方式的区别

多态 polymorphism

多态：同一个对象同一个方法表现状态不同。
水，绝对零度下-273°（固态），平时温度（液态）

java在多时它一般有一个前提，继承之后发生。
1）子类覆盖Object的toString()方法，重写override，把父类的方法重新定义，运行时多态
2）基本类型的判别 int、byte、short。。。，相同的方法名，但是它的参数类型不同，重载overload，编译器多态

重写，运行时多态

package cn.tedu.entity;

//创建学生类，重新它的toString方法
public class Student {
	//私有属性
	private Integer sno;	//学号
	private String name;	//学生姓名
	private String school;	//毕业学校
	private String address;	//地址
	
	//生成get和set方法
	public Integer getSno() {
		return sno;
	}
	public void setSno(Integer sno) {
		this.sno = sno;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	
	@Override
	public String toString() {
		return "Student [sno=" + sno + ", name=" + name + ", school=" + school + ", address=" + address + "]";
	}
}

package test;

import cn.tedu.entity.Student;

public class TestStudent {
	public static void main(String[] args) {
		Student student = new Student();
		
		student.setSno(100);
		student.setName("王琪");
		student.setSchool("清北");
		student.setAddress("五道口");
		
		//同样是一个toString方法，但由于重写后，和重新前表现形式不同，多态
		//什么时候确定呢？父类和子类都有toString方法，此时运行到这里，那调用哪个方法呢？
		//上面是动态选择的，所以称为运行时多态。
		System.out.println(student.toString()); //最终调用子类方法，就近原则
	}
}

重载，编译期多态

package test;

//需求：给定某个8基本类型，声明一个变量，打印出变量的类型
public class TestType {
	//重载，方法名相同，参数类型不同
	public void println(byte x) {
		System.out.println("byte类型");
	}

	public void println(short x) {
		System.out.println("short类型");
	}

	public void println(int x) {
		System.out.println("int类型");
	}

	public void println(long x) {
		System.out.println("long类型");
	}

	public void println(float x) {
		System.out.println("float类型");
	}

	public void println(double x) {
		System.out.println("double类型");
	}
	public void println(char x) {
		System.out.println("char类型");
	}
	public void println(boolean x) {
		System.out.println("boolean类型");
	}

	public static void main(String[] args) {
		//double x = 100.0;
		//char x = 'a';
		boolean x = true;

		// 1.创建类对象实例
		TestType tt = new TestType();

		// 2.调用方法，设置值
		// 编译时，x已经知道它的类型了，称作编译期多态
		// 多态，同一个方法同一个参数，但是结果却不同
		tt.println(x); // 强制设置100为字节类型
	}
}