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

-------  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学习型技术博客、期待与您交流！ ----------