课程链接:共六天
第一天:开发环境:初识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 (里面全是抽象方法,子类去实现)