Day12(java面向对象)学习记录（继承与抽象类）

大纲

Day02(java面向对象)学习目标

【学习目标】理解、了解、应用、记忆

通过今天的学习，参训学员能够：（解释的时候说出二级目标的掌握程度）

1. 【应用】继承

1. 【应用】能够独立使用继承关键字
2. 【理解】能够阐述继承的特点
3. 【理解】能够独立阐述继承中成员的特点
4. 【应用】能够独立使用方法的重写完成相关案例
5. 【应用】能够独立阐述继承中构造方法的执行顺序
6. 【理解】能够理解this与super使用

1. 【理解】抽象类

1. 【理解】能够独立阐述抽象类的概念
2. 【理解】能够独立阐述抽象类的特点
3. 【理解】能够独立阐述抽象类中成员的特带你
4. 【应用】能够独立完成抽象类中三个案例

 

收获：

1基本继承代码

 package com.itheima_01;

public class ExtendsDemo2 {
	public static void main(String[] args) {
		LOL l = new LOL();
		l.update();
		l.start();
	}
}

class Game {
	public void start() {
		System.out.println("游戏启动了");
	}
}

class PCGame extends Game {
	public void update() {
		System.out.println("PCGame更新了");
	}
}

class MobileGame extends Game {
	public void update() {
		System.out.println("MobileGame更新了");
	}
}

class LOL extends PCGame {
	
}

2java中super、this用法

package com.itheima_01;

public class ExtendsDemo3 {
	public static void main(String[] args) {
		Kid3 k = new Kid3();
		k.show();
	}
}

class Dad3 {
	String name = "建霖";
}

class Kid3 extends Dad3 {
	String name = "四葱";
	
	public void show() {
		String name = "五葱";
		
		System.out.println(super.name);
		System.out.println(this.name);
		System.out.println(name);
	}
}

3 继承中成员方法的特点&方法重写

A:子类中没有这个方法,调用父类的

 package com.itheima_01;
/*
 * 继承中成员方法的特点
 * 		子类中没有这个方法，调用父类的
 
 
 */
public class ExtendsDemo4 {
	public static void main(String[] args) {
		Kid4 k = new Kid4();
		k.eat();
	}
}

class Dad4 {
	public void eat() {
		System.out.println("小酌两口");
		System.out.println("去睡觉了");
	}
}

class Kid4 extends Dad4 {
   
}

B: 子类中重写了这个方法，调用子类的

 package com.itheima_01;

public class ExtendsDemo4 {
	public static void main(String[] args) {
		Kid4 k = new Kid4();
		k.eat();
	}
}

class Dad4 {
	public void eat() {
		System.out.println("小酌两口");
		System.out.println("去睡觉了");
	}
}

class Kid4 extends Dad4 {
	public void eat() {
		System.out.println("好好吃饭");
	}
}

4继承中构造方法的执行顺序

package com.itheima_01;
/*
 * 继承中构造方法的执行顺序
 * 			在子父类中，创建子类对象，调用子类的构造方法，
 * 			在子类的构造方法的第一行代码如果没有调用父类的构造，或者没有调用子类的其他构造，即使调用了子类的其他构造，也默认调用父类无参构造
 * 为什么要调用父类构造？
 * 			因为需要给父类的成员变量初始化
 * 肯定会先把父类的构造执行完毕，在去执行子类构造中的其他代码
 * 
 * 我是父类无参构造 --- 我是子类有参构造 --- 我是子类无参构造
 */
public class ExtendsDemo6 {
	public static void main(String[] args) {
		//Die d = new Die();
		Zi6 z = new Zi6();
	}
}

class Die6 {
	public Die6() {
		System.out.println("我是父类无参构造");
	}
	
	public Die6(int num) {
		System.out.println("我是父类有参构造");
	}
}

class Zi6 extends Die6 {
	public Zi6() {
		//super(1);
		//super();
		
		this(1);//会调用父类的无参构造了
		
		System.out.println("我是子类无参构造");
	}
	
	public Zi6(int num) {
		//会默认调用父类无参构造
		System.out.println("我是子类有参构造");
	}
}	

5抽象类：老师案例

 package com.itheima_02;
/*
 *	基础班老湿，就业班老湿
 *
 *	共性：
 *		属性	姓名，年龄，性别
 *		行为	讲课，唱歌
 */
public class AbstractTest {
	public static void main(String[] args) {
		BasicTeacher bt = new BasicTeacher();
		bt.name = "风清扬";
		bt.teach();
		
		JobTeacher jt = new JobTeacher();
		jt.name = "苍老师";
		jt.teach();
	}
}

abstract class Teacher {
	
	String name;//姓名
	int age;//年龄
	String gender;//性别
	
	//讲课
	public abstract void teach();
}

class BasicTeacher extends Teacher {

	@Override
	public void teach() {
		System.out.println(name + "讲基础班课程");
		
	}
	
}

class JobTeacher extends Teacher {

	@Override
	public void teach() {
		System.out.println(name + "讲就业班课程");
	}
	
}

6抽象类：雇员案例

  package com.itheima_02;
/*
 *	雇员(Employee)示例：
	需求：
		公司中 
			程序员(programmer)有姓名(name)，工号(id)，薪水(pay)，工作内容(work)。
			项目经理(Manager)除了有姓名(name)，工号(id)，薪水(pay)，还有奖金(bonus)，工作内容(work)
			
	员工：
		属性 name，id，pay
		行为 work
 */
public class AbstractTest2 {
	public static void main(String[] args) {
		Programmer p = new Programmer();
		p.work();
		
		Manager m = new Manager();
		m.work();
	}
}

abstract class Employee {
	String name;//姓名
	String id;//id
	double pay;//薪水
	
	//工作
	public abstract void work();
	
}

class Programmer extends Employee {

	@Override
	public void work() {
		System.out.println("写代码");
	}
	
}

class Manager extends Employee {
	byte bonus;
	
	@Override
	public void work() {
		System.out.println("盯着程序员写代码");
	}
	
}

7知识点：

1继承优缺点

A:优点：    提高了代码的复用性        提高了代码的可维护性

B:缺点：    类的耦合性增强了

 

面向对象开发原则：高内聚低耦合

内聚：就是自己完成某件事情的能力       耦合：类与类的关系

原因：    高内聚是值得要的,因为它意味着类可以更好地执行一项工作.低内聚是不好的,因为它表明类中的元素之间很少相关.成分之间相互有关联的模块是合乎要求的.每个方法也应该高内聚.大多数的方法只执行一个功能.不要在方法中添加’额外’的指令,这样会导致方法执行更多的函数.

               耦合是类之间相互依赖的尺度.如果每个对象都有引用其它所有的对象,那么就有高耦合,这是不合乎要求的,因为在两个对象之间,潜在性地流动了太多信息.低耦合是合乎要求的:它意味着对象彼此之间更独立的工作.低耦合最小化了修改一个类而导致也要修改其它类的”连锁反应”. 

 

2抽象

分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。