【小白学java】java的面向对象设计：封装+继承+抽象类+接口（day06）

课程链接：共六天

第一天：开发环境：初识java，搭建环境
第二天：语言基础：关键字、变量、常量、运算符
第三天：数据结构：基本类型、包装类型、引用类型（数组和对象）
第四天：流程控制：分支判断、循环迭代、异常处理
第五天：API工具类：字符串方法、身份证解析
第六天：面向对象：封装、继承、抽象、接口

知识回顾

1）java api 应用程序接口（我们写的程序如何去调用jdk提供工具包，我们的程序代码如何和jdk的代码对接）
我们无需直接去面对硬件。Scanner对象，相关方法 nextInt()。我们的代码调用jdk提供api就可以操作计算机硬件。
2）系统有很多api，api手册，太多了，我建议百度，demo例子。更贴近开发。
3）常用的api方法都要记忆下来，有印象能百度，仿写（开发开卷考试）
4）实际开发就是利用api各个方法组合调用，最终实现用户需求

面向对象

1）面向过程（早期）、面向对象（主流）、面向服务（SOA、微服务）（主流，在面向对象基础上）
2）面向过程和面向对象的区别？
编程思想，做一件同样事情，做的思路不同。
思路不同在哪里？
例子：把大象放到冰箱里。（本意：把公大象放到格力冰箱中）需求变更

面向过程：开发步骤（流水账）

a. 把冰箱门打开
b. 把什么放进去：大象
c. 把大象放入冰箱
d. 把冰箱门关上
找出主体：名词（冰箱、大象），围绕它做事
找出动作：动词（打开、放入、关上），强调过程
面向过程：找出把名词主体，和动作（动词）连接起来，最后怎么完成整个过程！

面向对象：

a. 找出主体（名词：冰箱、大象）
b. 创建模型：（额外考虑，感觉画蛇添足）
冰箱：容大、颜色、品牌、耗电、打开、关上
大象：产地、公母、皮、腿
c. 执行步骤
打开冰箱，把大象放入冰箱，关上门

它考虑额外事情，目前为止用户不关心。

在实际开发中，用户不遵守他的话，他说的话不算数。
实际开发中，无法完全（合同），无法严格按合同执行，开发者就必须适应用户的需求变更。
从这一实际角度出发，面向过程思考好还是面向对象思考好！
如果按照面向过程思考，它不能适应用户需求变更，要修改代码，加班加点完成。前面考虑不够完善。
如果按照面向对象思考，它提前考虑很多细节，超过用户要求，表面上多考虑了，但是当用户需求变化，刚好就在我们多考虑范畴中！代码不需改，改动量很少。按期完成，无需额外资金投入。

面向对象要考虑很多，考虑范围，不能太广，过渡设计。设计都需要人力物力。
有一个平衡点，设计多大范围合适呢？ 系统分析师（高薪！）8年

到超市购买商品

第一次用户提出需求：要购买白酒和花生米
第二次用户提出需求：要购买白酒和花生米，买猪头肉（需求变更）
第三次用户提出需求：+ 凉菜
用户变化n次

面向过程：
1）到哪个超市
2）挑选商品（白酒、花生米）2种，
3）购买，结束
每次需求都要改，有可能之前代码框架都无法适应新需求，翻天覆地重做。

面向对象：
1）都有哪些超市，都有哪些商品，对超市商品全部建模 2000种商品
2）到某个超市，挑选商品（白酒、花生米、猪头肉、凉菜）
3）购买，结束

总的来说：面向对象优于面向过程设计，主流设计思想面向对象设计！

java是怎么支持面向对象设计的？

java面向对象，c面向过程，c++面向对象，python面向对象，javascript面向对象，vue框架面向对象
java 四大特性：围绕面向对象而言：封装、继承、多态、抽象

封装

面向过程过程中每个细节都需要开发者去了解，封装改变这样方式，它先进行建模，把名称创建对象，设置它的属性（代表这个事物的特点）和方法（表现一些动作）
把生活中的物品抽象成java中的对象
对象为了简单，有些内容对外暴露，有些内容隐藏。隐藏就体现了封装。
例子：手机
如果知道手机所有细节，我们现在都用不上手机。
1）对外暴露：屏幕、键盘、话筒、耳机、充电器
2）隐藏：怎么通讯，运行app
对有些内容使用者是不关心它的内部实现，手机把这些内容进行封装，用户使用就简单了。

代码如何实现封装呢？
有些功能用户不能去访问，用户不需要知道内容封装。
它需要知道，我们会单独给它接口api

手机：

1）创建一个类：Phone
2）类中封装，对外看不到，创建属性 call、keys，私有 private （体现了封装）
3）对外暴露：怎么开发call，怎么开发keys？公有 public

package cn.tedu.oop;

//模拟手机建模（建立模型）需求中的名词
public class Phone {
	//成员变量，可以在多个方法中直接调用
	private String call;			//模拟打电话特性
	private String keys;		//模拟手机键盘特性
	
	//如何对外暴露私有的属性，对其进行操作。
	//使用getXxx（获取）和setXxx（设置）方法来操作私有属性
	//这个业界的规范，开发工具都直接支持自动产生对应属性的get和set方法
	
	//私有属性外部不能访问，但在类的内部的方法可以直接访问
	public String getCall() {
		return call;
	}
	
	//外部怎么去设置成员变量值呢？setCall方法的参数
	public void setCall(String call) {
		//前面成员变量，后面是参数，参数就保存了用户设置值，
		//以后用户使用get方法就可以获取新的值
		//参数名和成员变量的名称重复，怎么区分谁是谁呢？
		//this.value就可以区分，this代表本类，对象，this.value代表成员变量，就不是参数名
		this.call = call;
	}
	public String getKeys() {
		return keys;
	}
	public void setKeys(String keys) {
		//警察，监听电话，
		//用户只管调用setKeys方法，它并不知道这块代码
		if( keys.equals("110") ) {		//判断keys值是否为110
			System.out.println("通知警察");
		}
		
		this.keys = keys;
	}

}

package cn.tedu.oop;

import org.junit.Test;

public class TestPhone {
	@Test
	public void phone() {
		//1. 创建类的实例（对象）
		Phone phone = new Phone();
		
		//2. 通过对象点操作符访问其共有属性
		//The field Phone.call is not visible 在外部不能访问私有属性
//		phone.call = "打电话给老婆";
//		phone.keys = "135";
		
		System.out.println( phone.getCall() );
		phone.setCall("打电话给老婆");
		System.out.println( phone.getCall() );
		
		System.out.println( phone.getKeys() );
		phone.setKeys("110");
		System.out.println( phone.getKeys() );
	}
}

封装的好处

1）把不让外界知道的信息就隐藏起来，外部无法操作。代码比较安全，外部无法操作。
2）代码只能内部处理。当代码修改，所有调用地方都要随之改变，这种结构紧耦合。如果代码只能内部修改，修改后，外部丝毫不影响，这种结构松耦合。程序能实现松耦合就松耦合。封装就实现松耦合结构。内部修改不影响其他代码。
3）封装后，里面程序实现细节，对应调用者来说不关心，只关心如何使用。把复杂问题变简单。

继承

什么叫继承？
java中继承和生活继承是一样一样的。父类（父亲）和子类（自己）。父亲父亲，子类子类。
java继承单继承，c语言允许多继承（c语言代码质量出错，很难找的其中一个原因）。

结论：java中单继承，但是可以多层

java中如何实现继承关系？

实现继承关系提供2个方式：
1）extends关键字（继承）：语法extends后面跟类（class 实现类、abstract class 抽象类）
Tiger extends Animal
Eagle extends Animal
特点：Animal是一个实现类，它具体实现eat方法

抽象类特点：它有部分实现（父类自己实现）和部分规定不实现的（子类去实现）
Tiger extends AbstractAnimal（抽象类中有抽象方法，抽象方法父类不实现，压到子类去实现）

2）implements 关键字（实现）：语法implements后面跟接口（interface）
接口特点：所有方法都是抽象方法，一点活都不干，它指手画脚（它要规定子类实现方法）

为什么要使用继承？

我们可以从父类继承它的属性和方法，在子类中直接调用父类资源（属性和方法），方法和属性都是public。

package cn.tedu.old;

//创建了老虎类
public class Tiger {
	//吃东西
	public void eat() {
		System.out.println("吃肉肉");
	}
	
	//跑的快
	public void run() {
		System.out.println("我是陆地之王，我跑得快");
	}
}

package cn.tedu.old;

//创建了鹰类
public class Eagle {
	//吃东西
	public void eat() {
		System.out.println("吃肉肉");
	}
	
	//飞的高
	public void fly() {
		System.out.println("我是天空之王，我飞得高");
	}
}

通过对上面两个类的观察：
1）它们有共性，eat方法一样
2）它们有个性，Tiger类它有自己的run()方法，Eagle类它有自己的fly()方法。
有共性有不同！

package cn.tedu.old;

//动物测试类
public class TestAnimal {
	public static void main(String[] args) {
		//先创建对象，通过对象.方法，来执行对象某个方法
		Tiger tiger = new Tiger();	//创建一个老虎对象
		tiger.eat();	//调用eat方法
		tiger.run();	//调用run方法
		
		Eagle eagle = new Eagle();
		eagle.eat();	//调用eat方法
		eagle.fly();	//调用fly方法
	}
}

缺点：
共性的方法，出现在多个类中，如果业务需要修改，要修改多处，工作量大，容易造成失误，这个类改，那个类
忘改，造成结果不一致！

继承

解决办法？就是继承！
1）要把共性方法抽取出来，放到一个单独类中 Animal
2）把共性方法就从当前类中删除
3）两个类连接起来，使用继承，Tiger extends Animal，可以在子类中直接访问父类方法eat()

package cn.tedu.ext;

//提取共用方法，这个类叫Tiger和Eagle的父类（超类super）
public class Animal {
	//共用的方法
	public void eat() {
		System.out.println("我要吃肉肉");
	}
}

package cn.tedu.ext;

//创建老虎类，只写自己的方法，不写共用方法
//这个类继承Animal动物类，就可以使用它的资源
public class Tiger extends Animal{
	public void run() {
		System.out.println("我是陆地之王，我跑得快");
	}
}

package cn.tedu.ext;

//创建鹰类，不写共用方法，只写自己的方法
//继承动物类Animal，就可以使用它里面的方法
public class Eagle extends Animal{
	public void fly() {
		System.out.println("我是天空之王，我飞得高");
	}
}

package cn.tedu.ext;

public class TestAnimal {
	public static void main(String[] args) {
		// 怎么调用父类的资源？
		Tiger tiger = new Tiger();
		tiger.eat(); // 调用父类方法，不用写，调用现有资源
		tiger.run(); // 调用子类自己的方法，扩展父类内容

		Eagle eagle = new Eagle();
		eagle.eat();
		eagle.fly(); // 它只能调用父类和自己的，不能调用其它，隔离
	}
}

抽象类

package cn.tedu.abs;

//抽象类，使用abstract修饰
//特点：有一部分实现了，有一部分不实现（但是做规定）
public abstract class AbstractAnimal {
	//实现部分（公用，自己实现具体代码）
	public void eat() {		//它实现具体代码内容，它有方法体（实现）
		System.out.println("我要吃肉肉");
	}
	
	//规定部分（公用，自己不是代码只做规范，子类必须强制实现！！！
	//睡觉，睡的地方不同（都有睡觉需求，但具体方式不同）
	//抽象方法
	/*
	 * The abstract method sleep in type AbstractAnimal
	 *  can only be defined by an abstract class
	 *  抽象方法只能在抽象类中定义，不能在普通类中定义
	 */
	public abstract void sleep();  //它没有具体实现代码，它只是一个方法的声明
}

package cn.tedu.abs;

//继承的是抽象类，要实现抽象类中抽象方法
/*
 * The type Tiger must implement the inherited abstract method AbstractAnimal.sleep()
 * 你必须实现sleep()抽象方法。父类的抽象方法子类必须实现
 * */
public class Tiger extends AbstractAnimal{		
	public void run() {
		System.out.println("我是陆地之王，我跑得快");
	}

	//注解，告诉java，sleep方法覆盖父类方法
	@Override	//错误上点击选择，eclipse会把所有未实现方法加入，少写代码
	public void sleep() {
		System.out.println("老虎睡在平地上");
	}
}

package cn.tedu.abs;

public class TestAbstractAnimal {
	public static void main(String[] args) {
		Tiger tiger = new Tiger();
		tiger.eat();			//父类实现的方法
		tiger.run();			//自己的方法
		tiger.sleep();		//实现父类要求的方法（抽象方法）
	}
}

接口

package cn.tedu.inter;

//创建动物接口，规范所有方法都是抽象方法（此时不需要加 abstract关键字）
public interface InterfaceAnimal {
	//规定当前接口的实现类写的方法
	public void sleep(); 	//没有抽象关键字，也没有实现代码，方法的声明
	public void dead();
	
	//上面强制子类（实现类）都必须实现上面的所有的方法
}

package cn.tedu.inter;

//实现类，实现InterfaceAnimal接口，实现里面所有的方法
public class Tiger implements InterfaceAnimal{

	@Override	//实现接口的方法
	public void sleep() {
		System.out.println("老虎睡觉");
	}

	@Override //实现接口的方法
	public void dead() {
		System.out.println("老虎死亡");
	}

}

package cn.tedu.inter;

//调用接口的实现类
public class TestInterfaceAnimal {
	public static void main(String[] args) {
		Tiger tiger = new Tiger();
		tiger.sleep();
		tiger.dead();
	}
}

实现类和抽象类和接口区别

为什么需要抽象类？

学框架，框架中很多抽象类。例如：spring框架
框架要做很多底层公用事情，让我们写代码利用框架，程序更加健壮，更加安全，
业务需求私有事情，还的我们去实现
公用框架实现，私有我们自己实现，我们自己写代码怎么和框架对接。框架进行规定！
规范私有类（抽象方法声明）

为什么需要接口？

提倡面向接口开发，你可以实现接口，别人可不可以接口。
java JDBC 数据库一套规范，java自身规定接口，其他厂商去实现
mysql数据库厂商，Mysql的实现；oracle数据库厂商，oracle的实现。

小结

1）java 面向对象语言，面向过程围绕过程（解决问题步骤），面向对象围绕实体（名词，特性（属性），行为（动作、方法））。它们设计思想区别在于关心核心不同的。
主流都是面向对象的。
实际开发，先按面向对象思想进行设计，具体实现时面向过程（人习惯）
2）java怎么支持面向对象呢？
a. 万物皆对象，所有的类都是Object子类
b. java中支持单继承，多重继承，Tiger是Animal子类，Animal是Object的子类。满足单继承（每次都一个父类，超类）
c. 面向对象的4大特性：封装、继承、多态、抽象
3）封装的优点
a. 隐藏细节，开发者关注内容就少，好写代码，
b. 安全，你不需要知道我内部实现细节，private修饰后，外部不能访问。
c. 方便修改，私有，外部不能访问，修改不影响其他类（送耦合）
4）继承
a. extends 继承
a.1 继承实现类 class
a.2 继承抽象类 abstract class （必须有抽象方法，子类去实现）
b. implements 实现
实现接口 interface （里面全是抽象方法，子类去实现）