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

Posted 长安紫薯

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java小白训练营2109-day06-OOP:面向对象+封装+继承+多态相关的知识,希望对你有一定的参考价值。

面向对象

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

编程思想
面向过程:关注完成一个需求,代码实现步骤,每一步都完成,整个需求就实现。
面向对象:关注实体 entity,特征(属性)+行为(方法),建模(建立模型),然后在一步步的实现(步骤)

案例:把大象装入冰箱

面向过程思考的方式:步骤
第一步:把冰箱门打开,
第二步:把大象放入,
第三步:把冰箱门关上
(步骤)
面向对象思考的方式:实体+步骤
实体(从描述中挑名称)大象和冰箱
大象:特征(巨大、鼻子长、很重、…)行为(吃、跑、洗澡…)
冰箱:特征(门、电、容积…)行为(制冷、存储、开门、关门…)
(步骤)

案例:我去超市买葡萄、水饺、薯片、香蕉

面向过程:
第一步:出门,去超市
第二步:找葡萄、找水饺,买
第三步:回家
面向对象:
实体:葡萄、水饺、超市的所有商品!!!!!(香蕉、包子、薯片)
第一步:出门,去超市
第二步:找葡萄、找水饺、薯片、香蕉,买
第三步:回家

需求变更,(用户)
用户至上!ipad
实际开发,半面向对象,半面向过程,结合来实现具体的代码

面向对象的三大特征

封装、继承、多态、(抽象)

封装 encapsulation

作用:包装,不能看到它的内部结构,也不能了解其内部运行机制。封装后,好处使用起来简单,不需要知道它运行机制,照样使用。隐藏起来,让使用者更加方便简易。
String api ,这些方法你知道它怎么实现吗? 日常使用者是不知道的,也不需要知道。日常开发者知道其特性,能正确使用即可。toUpperCase() 特性外在表现,大写。
包装类型,它是引用类型,打印时不是,重写了toString方法,重写了hashcode(特殊处理)

封装案例,实体对象

Person实体
1)私有属性 private,对应每个私有属性
2)两个方法 getName() 获取,setName() 设置(eclipse直接自动生成)
上面的过程,私有是属性,它无法直接进行访问,必须通过新的get和set进行访问,特别是set
p.name =“tony”;
p.setName(“tony”);
setName内部在干什么,调用者它是不知道的,这个就是封装,隐藏实现细节。

package cn.tedu.entity;

/*
 * 实体类:
 * 1)一堆私有属性,见名知意
 * 2)每个属性都有get和set方法
 */
public class Person {
	private String name;	//姓名
	private Double money;	//薪水
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		//name参数
		//this.name 属性,成员变量 this代表当前类
		this.name = name;
	}
	
	public Double getMoney() {
		return money;
	}
	public void setMoney(Double money) {
		this.money = money;
	}
}

package cn.tedu.entity;

/*
 * 实体类:
 * 1)一堆私有属性,见名知意
 * 2)每个属性都有get和set方法
 * 3)不是必要,测试(调试)toString()
 */
public class Person {
	private String name;	//姓名
	private Double money;	//薪水
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public Double getMoney() {
		return money;
	}
	public void setMoney(Double money) {
		this.money = money;
	}
	
	@Override //注解,重写,覆盖父类Object.toString()方法
	public String toString() {
		return "Person [name=" + name + ", money=" + money + "]";
	}
}


package test;

import org.junit.Test;
import cn.tedu.entity.Person;

public class TestPerson {
	@Test
	public void person() {
		//1. 创建对象实例
		Person person = new Person();
		
		//2. 设置属性值
		person.setName("陈晨");
		person.setMoney(10000.0);
		
		//3. 获取属性值进行打印
		System.out.println(person.getName());
		System.out.println(person.getMoney());
		
		//4. 打印对象不是地址,而是想打印它的所有的内容
		System.out.println(person); 
		//打印对象实质是调用对象的toString方法,如果对象没有写这个方法,它会调用父类的toString();
		//为什么它不调用父类的方法,而调用自己的方法呢? 方法名相同是调用原则:就近原则
		System.out.println(person.toString());
	}
}


利用eclipse 自动生成get和set方法,以及toString()方法

继承 inheritance

java中继承和其他语言不同的,它提供两种方式
1)继承 extends 只能单继承,安全性高不易出错
2)实现 implements 可以实现多个接口,它的类也称为实现类

为什么需要类继承?

继承的好处是,可以减少相同的代码(冗余),当需要变化时,只需修改一处,所以调用的地方就都更新了。

package cn.tedu.entity;

//水果类
public class Fruit {
	public void eat() {
		System.out.println("水果可以吃");
	}
}


package cn.tedu.entity;

//苹果类,继承父类,父类的公用的方法就直接可以调用
public class Apple extends Fruit{
}

package cn.tedu.entity;

//梨类,代码冗余了?
public class Pear extends Fruit{
}

接口的实现方式

需求:
动物,老虎和兔子,他们都吃东西(共性)老虎吃肉肉,兔子吃草草

package cn.tedu.entity;

//接口,定规矩,定要求
//所有的类都得实现eat()方法
public interface Animal {
	//不实现,只定规矩
	//这里只定义规矩,子类去实现具体的代码
	public void eat(); //这里只是一个方法的定义,没有方式的实现代码
}


package cn.tedu.entity;

//老虎实现类
public class Tiger implements Animal{
	@Override
	public void eat() {
		System.out.println("老虎吃肉肉");
	}
}

package cn.tedu.entity;

//兔子实现类,遵守规矩,implements 接口
//它必须实现Animal接口中定义方法,必须写类的实现的代码
//The type Rabbit must implement 
//the inherited abstract method Animal.eat()
public class Rabbit implements Animal{
	@Override //覆盖,重写,有没有都可以,它是提示你覆盖父类的方法
	public void eat() {
		System.out.println("兔子吃草草");
	}
}


package test;

import org.junit.Test;

import cn.tedu.entity.Animal;
import cn.tedu.entity.Apple;
import cn.tedu.entity.Rabbit;
import cn.tedu.entity.Tiger;

public class TestAnimal {
	@Test
	public void animal() {
		//类的写法
		//格式:类名 实例名 = new 类名();
		Apple apple = new Apple();
		//接口的写法
		//格式:接口名称 实例名称 = new 实现类名称();
		//Cannot instantiate the type Animal 接口animal是不能实例化
		//Animal tiger = new Animal();
		Animal tiger = new Tiger();
		tiger.eat();
		
		Animal rabbit = new Rabbit();
		rabbit.eat();
	}
}




两种继承方式比较

多态 polymorphism

需求:人Person,喂小动物 feed( who )
现在有:老虎,兔子
person.feed(老虎)
person.feed(兔子)
需求变更:狗、猫
person.feed(狗)
person.feed(猫)
增不能写个通用的,代码量急剧降低,如果在有新的动物,person.feed(new)
person.feed(Animal)

package cn.tedu.entity;

/*
 * 实体类:
 * 1)一堆私有属性,见名知意
 * 2)每个属性都有get和set方法
 * 3)不是必要,测试(调试)toString()
 */
public class Person {
	private String name;	//姓名
	private Double money;	//薪水
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public Double getMoney() {
		return money;
	}
	public void setMoney(Double money) {
		this.money = money;
	}
	
	@Override //注解,重写,覆盖父类Object.toString()方法
	public String toString() {
		return "Person [name=" + name + ", money=" + money + "]";
	}
	
	//不通用的方式,有几个动物就得写多个个代码,代码量非常的大
	//喂老虎
	public void eat(Tiger tiger) {
		tiger.eat();
	}
	
	//喂兔子
	public void eat(Rabbit rabbit) {
		rabbit.eat();
	}
	
	//通用的结构,使用接口作为参数
	//如果有新的动物扩充,此时这里的代码无需修改
	public void eat(Animal animal) {
		//它的参数不能是接口,但是接口的子类
		//实现类,实现类中写了具体代码
		animal.eat();
	}
}


package cn.tedu.entity;

//猫类,实现Animal它的接口,必须实现Animal定义的所有的方法
public class Cat implements Animal{
	@Override
	public void eat() { //遵循Animal定义eat方法,守规矩
		System.out.println("猫吃小鱼");
	}

}


package test;

import org.junit.Test;

import cn.tedu.entity.Animal;
import cn.tedu.entity.Cat;
import cn.tedu.entity.Person;
import cn.tedu.entity.Rabbit;
import cn.tedu.entity.Tiger;

public class TestPerson {
	@Test
	public void person() {
		//1. 创建对象实例
		Person person = new Person();
		
		//2. 设置属性值
		person.setName("陈晨");
		person.setMoney(10000.0);
		
		//3. 获取属性值进行打印
		System.out.println(person.getName());
		System.out.println(person.getMoney());
		
		//4. 打印对象不是地址,而是想打印它的所有的内容
		System.out.println(person); 
		//打印对象实质是调用对象的toString方法,如果对象没有写这个方法,它会调用父类的toString();
		//为什么它不调用父类的方法,而调用自己的方法呢? 方法名相同是调用原则:就近原则
		System.out.println(person.toString());
		
		//不通用的方式的调用,创建参数
		Tiger tiger = new Tiger();
		person.eat(tiger);
		
		Rabbit rabbit = new Rabbit();
		person.eat(rabbit);
		
		//通用的方式的调用,多态:同一个Animal但是最终结果是不同的
		Animal tiger2 = new Tiger();
		person.eat(tiger2);
		
		Animal rabbit2 = new Rabbit();
		person.eat(rabbit2);
		
		Animal cat = new Cat();
		person.eat(cat);
	}
}


小结

1)java面向对象
a. 面向过程:关注代码编写步骤,解决每个步骤中技术难点,使用工具代码实现即可
b. 面向对象:关注实体创建(建模)特征(私有属性)公有的get和set方法,eat()业务方法,然后咱步骤实现
c. 面向切面:AOP 它是面向对象的有益补充,但是必须现有面向对象,才有面向切面
d. 面向服务:SOA,SOA最佳实践:微服务 SpringCloud Alibaba
2)面向对象这种编程思想为何会胜出面向过程?
需求变更(满足一定的代码变化)
取个平衡点,编程要适度(超市不可能把所有的商品建模,可以超出当前的需求,把常用的都建模)
主流的开发思想是使用面向对象,java,c++,python
3)面向对象概念:三大特征
a. 封装:被隐藏起来,开发者需要知道的内容就少了,代码也更加少,好处开发者容易学习
b. 继承:两种实现方式
b1:extends 继承类,公用代码都写在父类中,代码量急剧降低,每个子类无需写相同重复代码,复用
b2:implements 实现接口,没有少写代码,它的作用就是定义规范,所有的子类都必须遵守
c. 多态:同一个事务可以展现出不同的结果 Animal tiger.eat 吃肉肉,rabbit.eat 吃草草
好处,代码通用,向后兼容 Tiger,Rabbit
4)封装具体的实现
a. 创建实体类 entity
b. 一堆的私有属性(特性),外部不能直接访问 private String name;
c. 一堆的get和set方法来调用(行为)getName()、setName();
d. 一堆业务的方法(行为) eat(), play()。。。
5)类的继承
a. java单继承,就想继承多个类?多级继承,爷爷-父亲-我,没有c语言多继承灵活,但安全,不易出错,出错好找的问题的所在类
b. 把公用的代码就写在父类中
c. 怎么表达是当前的类 this,还是父类 super?
d. 子类调用 Fruit 水果是父类,Apple是子类,怎么调用父类方法
d1)声明它们之间的关系,继承关系:class Apple extends Fruit
d2)调用 Apple apple = new Apple(); apple.eat(); 执行时,先到本类查找,没有eat方法,它就去父类查找方法eat()
好处:复用代码 apple可以调用fruit.eat(),pear可以调用fruit.eat()
6)接口的实现
a. 定义接口,只写方法的定义。规定方法返回值,方法名称,方法的参数
b. 实现接口 Animal tiger = new Tiger(); 关系表达 class tiger implements Animal;
c. 在tiger就必须实现Animal接口中所有的方法定义
好处:规范代码,实现向后兼容,程序就方便扩展 JDBC
主流开发方式提倡,面向接口开发!
7)类和接口的本质差异
a. 类使用class修饰,接口使用 interface修饰
b. 类中内容都必须实现,接口中没有实现的代码
c. 类是可以被extends继承的,任何类都可以有子类;接口实现接口(多级)
d. 类干活,接口不干活
8)多态
a. 同一个类,表现出不同的结果

package test;

public class TestMain {
public static void main(String[] args) {
int i = 100; //整数
String s = “abc”; //字符串

	//运行时多态
	System.out.println(i);
	System.out.println(s);
}

}

以上是关于java小白训练营2109-day06-OOP:面向对象+封装+继承+多态的主要内容,如果未能解决你的问题,请参考以下文章

java小白训练营2109-day01-知识回顾

java小白训练营2109-day01搭建开发环境

java小白训练营2109-day05-知识回顾

java小白训练营2109-day03-知识回顾

java小白训练营2109-day04-流程控制:分支判断+循环迭代+异常

java小白训练营2109-day03-数据结构:基本类型+包装类型+数组+对象