【黑马程序员】面向对象（三） 第七天

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------

知识点

可以从现有的类派生出新类。这个称为类的继承。新类称为次类、子类或派生类。现有的类称为超类、父类或基类。

抽象类和常规类一样，都有数据和方法，但是不能用new操作符创建抽象类的实例。

非抽象类中不能包含抽象方法。如果抽象类中子类没有实现所有被继承的父类抽象方法，就必须将子类也定义为抽象类。

包含抽象方法的类必须是抽象类。但是，抽象类可以不包含抽象的方法。

即使父类是具体的，子类也可以是抽象的。

接口是一种与类相似的结构，只包含常量和抽象方法。接口在许多方法与抽象类相近，但抽象类除了包含常量和抽象方法外，还可以包含变量和具体方法。

接口被认为是一种特殊的类。就像常规类一样，每个接口都被编译为独立的字节码文件。

接口java.lang.comparble定义了compareTo方法。Java类库中的许多类都实现了Comparable。

一个类仅能继承一个父类，但一个类却可以实现一个或多个接口。

一个接口可以扩展一个或多个接口。

01）继承-概述1

public class PersonDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.name = "汤姆";//设置name属性。
		s.age = 4;//设置age属性。
		s.study();
		Worker w = new Worker();
		w.name = "杰瑞";
		w.age = 3;
		w.work();
	}
}

class Person{//父类
	String name;
	int age;
}
class Student extends Person{//继承Person类。
	void study(){
		System.out.println(name + "今年" + age + "岁。");
	}
}
class Worker extends Person{//继承Person类。
	void work(){
		System.out.println(name + "今年" + age + "岁。");
	}
}

运行结果如下图所示：

02）继承-概述2

03）聚集关系

按照事物的紧密联系程度分为：聚合以及组合。

聚合的例子：一个球队少个球员后，对这个球队的影响并不大。

组合的例子：一个人缺失一个手后，那对这个人的影响是非常大的。

04）子父类中变量的特点

public class PersonDemo_2 {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}
class Fu{
	int num = 4;
}
class Zi extends Fu{
	int num = 5;
	void show() {
		System.out.println("Num is " + num);//指向new Zi()对象。
	}
}

运行结果如下：

Num is 5

05）覆盖

public class PersonDemo_3 {
	public static void main(String[] args) {
		Zi_1 z = new Zi_1();
		z.show();
		z.speak();
	}
}
class Fu_1{
	void show() {
		System.out.println("Fu_1 show!");
	}
	void speak() {
		System.out.println("VB");
	}
}
class Zi_1 extends Fu_1{
	void show() {
		System.out.println("Zi_1 show!");
	}
	void speak() {
		System.out.println("Java");
	}
}

运行结果如下所示：

Zi_1 show!
Java

06）子类实例化过程

public class PersonDemo_4 {
	public static void main(String[] args) {
		Zi_4 z1 = new Zi_4();
		Zi_4 z2 = new Zi_4("3）其次...运行！");
	}
}
class Fu_4{
	Fu_4(){
		System.out.println("1）首先运行！");//首先运行
	}
}
class Zi_4 extends Fu_4{
	Zi_4(){
		//super();
		System.out.println("2）其次...运行！");//其次
	}
	Zi_4(String s){
		//super();//再调用运行一次
		System.out.println(s);//参数传递。
	}
}

运行结果如下图所示：

07）finally关键字

final类不能被继承，没有子类，final类中的方法默认是final的。 
final方法不能被子类的方法覆盖，但可以被继承。 
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 
final不能用于修饰构造方法。 
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

public class FinalDemo extends Final{ 
	public void f1(){ 
		System.out.println("Test1父类方法f1被覆盖!"); 
	}
	public static void main(String[] args) { 
		Final t=new Final(); 
		t.f1(); 
		t.f2(); //调用从父类继承过来的final方法 
		t.f3(); //调用从父类继承过来的方法 
		//t.f4(); //调用失败，无法从父类继承获得 
	}
}
class Final { 
	public static void main(String[] args) { 
	}	
	public void f1() { 
		System.out.println("public void f1()"); 
	} 
	//无法被子类覆盖的方法 
	public final void f2() { 
		System.out.println("public final void f2()");
	} 
	public void f3() { 
		System.out.println("public void f3()"); 
	} 
	private void f4() { 
		System.out.println("private void f4()"); 
	} 
}

运行FinalDemo。运行结果如下：

public void f1()
public final void f2()
public void f3()

08）抽象类

/*
 * 当多个类中出现相同功能时，但是功能主体不同。
 * 这时可以进行向上抽取。只抽取功能定义，不抽取功能主题。
  * 抽象类和一般类没有太大的不同。
 * 该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
 * 这些不确定的部分，也是该事物的功能，需要明确出现。但是无法确定主体，通过抽象方法来表示。
 * 抽象类比一般类多了个抽象方法。
 * 抽象类不可以实例化。
 * 
 * 特殊：抽象类中可以不定义抽象方法，这样做仅仅是为了不让该类建立抽象对象。
 */
public class AbstractDemo {
	public static void main(String[] args) {
		new BaseStudent().study();
		new AdvStudent().study();
		//new WorkStudent().study1();//不能用new创建抽象类的实例。
	}
}
abstract class Student_1{//抽象类
	abstract void study();//抽象方法
}
class BaseStudent extends Student_1{
	void study() {
		System.out.println("Base study");
	}
}
class AdvStudent extends Student_1{
	void study() {
		System.out.println("Adv study");
	}
}
abstract class WorkStudent extends Student_1{//没有实现抽象类中的所有方法，所以子类必须定义为abstract。
	void study1() {
		System.out.println("Work study");
	}
}

运行结果如下：

Base study
Adv study

10）练习

public class EmployeeDemo {
	public static void main(String[] args) {
		Pro p = new Pro("张三", "0x9999", 0.1);
		p.work();
		Manager m = new Manager("李四", "0x0001", 100000, 200000);
		m.work();
	}
}
abstract class Employee{//员工类。
	private String name;
	private String id;
	private double pay;
	Employee(String name, String id, double pay){
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	abstract void work();//普通员工与经理需要做不同的活，所以定义为abstract。
}

class Pro extends Employee{//普通员工类。
	Pro(String name, String id, double pay){
		super(name, id, pay);//直接调用
		System.out.println(name + "的员工号是：" + id + "\t月工资为：" + pay + "RMB");
	}
	void work(){
		System.out.println("Pro work!");//普通员工需要干的活。
	}
}

class Manager extends Employee{//经理类。
	private int bonus;
	Manager(String name, String id, double pay, int bonus){
		super(name, id, pay);//直接调用
		this.bonus = bonus;
		System.out.println(name + "的员工号是：" + id + "\t月工资为：" + pay + "$\t年终奖是：" + bonus + "$");
	}
	void work(){
		System.out.println("Manager work!");//经理需要干的活。
	}
}

运行结果如下图所示：

11）模版方法设计模式

public class GetTimeDemo {
	public static void main(String[] args) {
		SubTime s = new SubTime();
		s.getTime();
	}
}
abstract class GetTime{//获取程序运行的时间。
	public final void getTime(){
		long StartTime = System.currentTimeMillis();
		runcode();
		long EndTime = System.currentTimeMillis();
		System.out.println("程序运行时间：" + (EndTime - StartTime) + "毫秒");
	}
	abstract void runcode();//需要测试的程序。
}

class SubTime extends GetTime{
	int sum = 0;
	void runcode(){//覆盖父类中的runcode()方法。
		for (long i = 1; i < 1000000; i++){
			sum += i;
		}
		System.out.println("所有数的和： " + sum);
	}
}

运行结果如下图所示：

12）接口

格式：interface{}

接口中的成员修饰符是固定的。

成员常量：public static final

成员函数：public abstract

public class InterfaceDemo {
	public static void main(String[] args) {
		Test_1 t = new Test_1();
		System.out.println("t.PI: " + t.PI);//通过Test_1类的引用调用调用从接口继承过来的PI属性值。
		System.out.println("Test_1.PI: " + Test_1.PI);//通过子类Test_1直接调用从接口继承过来的PI属性值。
		System.out.println("Inter.PI: " + Inter.PI);//通过接口直接调用PI的属性值。
	}
}

interface Inter{//接口
	public static final double PI = 3.14159;
	public abstract void show();
}

class Test_1 implements Inter{//实现接口
	public void show(){}//实现抽象类
}

运行结果如下所示：

t.PI: 3.14159
Test_1.PI: 3.14159
Inter.PI: 3.14159

13）接口的特点

接口是对外暴露的规则。

接口是程序的功能扩展。

接口是用来实现的。

类与接口之间是实现关系。而且类可以继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

附言：我是Java新人，如有错误的地方请指出。

每天学习一点点，纠错一点点，进步很大点。

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------