深度解析：java必须掌握的知识点——类的重用

标签：管理   public   取消   point   间接   声明   接口   nat   实例   

类继承的概念

根据已有类来定义新类,新类拥有已有类的所有功能。

Java只支持类的单继承,每个子类只能有一一个直接超类（父类）。

超类是所有子类的公共属性及方法的集合，子类则是超类的特殊化。

继承机制可以提高程序的抽象程度，提高代码的可重用性。

超类和子类
子类对象与超类对象存在“是一个…”或“是一种…”的关系。

子类对象

从外部来看,它应该包括
与超类相同的接口
可以具有更多的方法和数据成员
其内包含着超类的所有变量和方法
继承的语法

[ClassModifier] class ClassName extends SuperClassName
{
    //类体
}

类继承举例
设有三个类: Person（人）, Employee（员工）,Manager（管理人员）。很明显：Person是范围最广的一个，Employee次之，Manager的范围最小，其类层次如图:

有如下代码：
Preson.java

public class Person {
    public String name;
    public String getName() {
    return name;
    }
}

Employee.java

public class Employee extends Person {
    public int employeeNumber;
    public int getEmployeeNumber() {
        return employeeNumber;
    }
}

Manager.java

public class Manager extends Employee {
    public String responsibilities;
    public String getResponsibilities() {
        return responsibilities;
    }
}

可以看出Employee（员工）是一种特殊的Person（人），所以Employee继承于Person类。而Manager（管理人员）是一种特殊的Employee（员工），所以Manager继承于Employee类。
下面为测试类：

public class Test {
    public static void main(String args[]){
        Employee li = new Employee();
        li.name = "Li Ming";
        li.employeeNumber = 123456;
        System.out.println(li.getName());
        System.out.println(li.getEmployeeNumber());
        Manager he = new Manager();
        he.name = "He Xia";
        he.employeeNumber = 543469;
        he.responsibilities = "Internet project" ;
        System.out.println(he.getName());
        System.out.println(he.getEmployeeNumber());
        System.out.println(he.getResponsibilities());
    } 
}

类中定义了一个Employee类li,输出li的名字和编号
一个Manager类he,输出he的名字，编号和职责。

运行结果：

属性的隐藏

有以下代码：

class Parent {
    Number aNumber;
}

class Child extends Parent
    Float aNumber;
}

子类中声明了与超类中相同的成员变量名
从超类继承的变量将被隐藏
子类拥有了两个相同名字的变量，一个继承自超类,另-一个由自己声明
当子类执行继承自超类的操作时,处理的是继承自超类的变量，而当子类执行它自己声明的方法时，所操作的就是它自己声明的变量
那么如果子类想要访问被隐藏的属性该怎么办？

访问被隐藏的超类属性调用从超类继承的方法,则操作的是从超类继承的属性
本类中声明的方法使用"super.属性”访问从超类继承的属性
假设有两个类A1和B1

class A1{ 
   int x= 2;
   public void setx(int i){ 
       x=i;
   }
   void printa(){
       System.out.println(x);
   }
}

class B1 extends A1 { 
   int x=100;
   void printb(){ 
       super.x = super.x +10 ;
       System.out.println("super.x=" +
       super.x+" x=" + x); 
   }
}

之后运行测试代码：

public class Test {
    public static void main(String args[]){
        A1 a1=new A1();
        a1.setx(4);
        a1.printa();

        B1 b1 = new B1();
        b1.printb();
        b1.printa();

        b1.setx(6); // 将继承x值设置为6
        b1.printb(); 
        b1.printa();

        a1.printa();
    } 
}

运行结果：

方法覆盖

如果子类不需使用从超类继承来的方法的功能,则可以声明自己的同名方法,称为方法覆盖

覆盖方法的返回类型,方法名称,参数的个数及类型必须和被覆盖的方法一模一样

只需在方法名前面使用不同的类名或不同类的对象名即可区分覆盖方
法和被覆盖方法

覆盖方法的访问权限可以比被覆盖的宽松，但是不能更为严格

方法覆盖的应用场合

子类中实现与超类相同的功能,但采用不同的算法或公式;
在名字相同的方法中,要做比超类更多的事情;
在子类中需要取消从超类继承的方法。
方法覆盖的注意事项：

必须覆盖的方法
派生类必须覆盖基类中的抽象的方法,否则派生类自身也成为抽象类.
不能覆盖的方法
基类中声明为final的终结方法基类中声明为static的静态方法
调用被覆盖的方法
super.overriddenMethodName();

Object类

所有类的直接或间接超类,处在类层次最高点;
包含了所有Java类的公共属性。

Object类的主要方法

public final Class getClass(）
获取当前对象所属的类信息,返回Class对象。
public String toStringO
返回表示当前对象本身有关信息的字符串对象。
public boolean equals(Object obj)
比较两个对象引用是否指向同一对象，是则返回true ,否则返回false。
protected Object clone()
复制当前对象，并返回这个副本。
public int hashCode(）
返回该对象的哈希代码值。
protected void finalize() throws Throwable
在对象被回收时执行，通常完成的资源释放工作。

终结类与终结方法

用final修饰的类和方法;
终结类不能被继承;
终结方法不能被子类覆盖。

抽象类

类名前加修饰符abstract ;
可包含常规类能包含的任何成员,包括非抽象方法;
也可包含抽象方法:用abstract修饰，只有方法原型,没有方法的实现;
没有具体实例对象的类,不能使用new方法进行实例化,只能用作超类;
只有当子类实现了抽象超类中的所有抽象方法，子类才不是抽象类，才能产生实例;
如果子类中仍有抽象方法未实现，则子类也只能是抽象类。
抽象类声明的语法形式

abstract class Number {
}

如果写new Number()将会编译错误。

抽象方法

声明的语法形式为:

public abstract <returnType> <methodName>(..);

仅有方法原型,而没有方法体;
抽象方法的具体实现由子类在它们各自的类声明中完成;
只有抽象类可以包含抽象方法。

抽象方法的优点

隐藏具体的细节信息,所有的子类使用的都是相同的方法原型，其中包含了调用该方法时需要了解的全部信息;
强迫子类完成指定的行为,规定所有子类的"标准”行为。

类的组合

组合的语法
将已存在类的对象放到新类中即可
例如，可以说"厨房( kitchen)里有一个炉子( cooker )和一一个冰箱( refrigerator )”。所以,可简单的把对象myCooker和myRefrigerator放在类Kitchen中:

class Cooker{  类的语句}
class Refrigerator{  类的语句}
class Kitchen{
    Cooker myCooker;
    Refrigerator myRefrigerator;
}

例：组合举例——线段类

一条线段包含两个端点

public class Point //点类
{
    private int x, y; //coordinate
    public Point(int x, int y){ this.x = x; this.y = y;}
    public int GetX() { return x; }
    public int GetY( { return y; }
}

class Line //线段类
{
    private Point p1,p2; // 两端点
    Line(Point a, Point b) {
        p1 = new Point(a.GetX(),a.GetY());
        p2 = new Point(b.GetX(),b.GetY());
    }
    public double Length() {
        return Math.sqrt(Math.pow(p2.GetX(-p1.GetX0,2)
        + Math.pow(p2.GetY0)-p1.GetY0.2));
    }
}

一个线段类包含两个端点，也就是组合了两个点类。

总结：看完有什么不懂的欢迎在下方留言评论，记得点个赞哦！

深度解析：java必须掌握的知识点——类的重用

标签：管理   public   取消   point   间接   声明   接口   nat   实例   

原文地址：https://blog.51cto.com/14801695/2494205