Java类的重用

墨蓝 2022-03-01 00:52 274阅读 0赞

1.  类的继承：根据已有类来定义新类，新类拥有已有类的所有功能。  
    超类是所有 子类公共属性和方法的集合，子类是超类的实例化。  
    子类对象：从外部看应该包括：  
    与超类相同的接口；可以有更多的方法和数据成员。  
    包含则会超类的所有变量和方法。

//继承的语法
    [ClassModdiffer] class ClassName extends SuperClassName { //类体 }

public class Person {
    	public String name;
    	public String getName() {
    		return (name);
    	}
    }
    public class Employee extends Person{
    	public int employeeNumber;
    	public int getEmployeeNumber() {
    		return employeeNumber;
    	}
    
    }
    public class Manager extends Employee{
    	public String responsibilities;
    	public String getResponsibilities() {
    		return responsibilities;
    	}
    
    }
    public class PersonTest {
    	public static void main(String[] args) {
    		Employee li = new Employee();
    		li.name = "li ming";
    		li.employeeNumber = 1234;
    		System.out.println(li.getName());
    		System.out.println(li.getEmployeeNumber());
    		
    	}
    }

隐藏和覆盖  
属性的隐藏：子类中声明了与超类中相同的成员变量名  
从超类继承的变量将被隐藏；子类拥有了两个相同名字的变量，一个继承自超类，另一个由自己声明。  
当子类执行继承自超类的操作时，处理的是继承字超类的变量，而当子类值执行它自己声明的方法时，所操作的就是它自己的变量。  
访问被隐藏的超类属性：调用从超类继承来的方法；本类中声明的方法使用“super.属性“访问从超类继承的属性。  
访问超类静态属性：静态成员不能别继承只能被访问。一旦被修改，即全局修改。

方法的覆盖：如果子类不需使用从超类继承来的方法的功能，则可以声明自己的同名方法，称为方法覆盖。  
覆盖方法的返回类型，方法名称，参数的个数及类型必须和被覆盖的方法一模一样；只需在方法名前使用不同的类名或不同类的对象名即可区分覆盖方法和被覆盖的方法。覆盖方法的访问权限可以比被覆盖的宽松，但是不能更为严格。  
应用场合：子类中实现与超类相同的功能，但采用不同的算法或公式；名字相同的方法中，功能更多；在子类中需要取消从超类继承的方法。  
方法覆盖的注意事项：  
必须覆盖的方法：派生类必须覆盖基类中抽象的方法，否则派生类自身也成为抽象类；  
不能覆盖的方法：基类中声明为final的方法；声明为static的静态方法。  
调用被覆盖的方法：`super.overriddenMethodName();`

1.  Object类：所有类的直接或间接超类，处在类层次的最高点；包含了所有Java类的公共属性。

Object类的主要方法：

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

相等和同一  
两个对象具有相同的类型，及相同的属性值，则称二者相等(equal)。  
如果两个引用变量指向的是同一个对象，则称这两个引用变量同一(identical)。  
两个对象同一，则肯定相等  
两个对象同一，则不一定相等  
equal方法默认判断同一，若想比较值是否相等，需要覆盖equals方法。

hashCode方法： 返回对象散列码的方法，一般规定是：在一个Java程序的一次执行过程中，如果对象“相等比较”所使用的信息没有被修改的话，同一对象执行hashCode方法每次都应返回同一个整数。在不同的执行中，对象的hashCode方法返回值不必一定一致。  
如果依照equals方法两个对象是相等的，则在这两个对象上调用hashCode()方法应该返回同样的整数结果。如果不想等，则不要求返回值不同。

clone方法：使用clone方法复制对象；  
覆盖clone方法：在Object类中被定义为protected，所以需要覆盖为：public。  
实现Cloneable接口，赋予一个对象被克隆的能力（cloneability)

class MyObject implements Cloneable { //.. . }

getClass方法：  
final方法，返回一个Class对象，用来代表对象所属的类。通过Class对象，可以查询类的各种信息：比如名字，超类，实现接口的名字等。

void PrintClassName (Object obj) {
    	System.out.println("The Object's class is " + obj.getClass().getName());
    }

finalize方法：  
对象被垃圾回收之前，系统自动调用对象的finalize方法。对象在何时，什么次序调用不保证。  
如果要覆盖finalize方法，覆盖方法的最后必须调用super.finalize。

1.  **终结类和终结方法**  
    用final修饰的类和方法；  
    终结类不能被继承；  
    终结方法不能被覆盖；
2.  **抽象类**：规定整个类家族各级子类都必须有的属性和方法。  
    类名前加修饰符：abstract；  
    可包含常规类能包含的任何成员，包括抽象方法；  
    也可包含抽象方法：用abstract修饰，只有方法原型，没有方法的实现；  
    没有具体实例对象的类，不能使用new方法进行实例化，只能用作超类；  
    只有当子类实现了抽象超类中的所有抽象方法，子类才不是抽象类，才能产生实例；  
    如果子类中仍有抽象方法未实现，则子类也只能是抽象类。  
    抽象方法的声明：`public abstract <returnType> <methodName>(...);`  
    仅有方法原型，而没有方法体；（还不能确定具体方法，只是对子类作规定）  
    抽象方法的具体实现由子类在它们各自的类声明中完成；  
    只有抽象类可以包含抽象方法。  
    抽象方法的有点：  
    统一设计整个类家族对外的公共服务接口；  
    隐藏具体的细节信息，所有子类使用得都是相同的方法原型，其中包含了调用该方法时需要了解的全部信息；  
    强迫子类完成指定的行为，规定所有子类的“标准行为”。

abstract class GrahpicObject {
    	int x, y;
    	void moveTo(int newX , int newY) {...}
    	abstract void draw();
    }
    
    class Circle extends GraphicObject {
    	void draw() {...}
    }

**7. 泛型**：将类型参数化。

//泛型类
    class GeneralType <Type> { 
    	Type object;
    	public GeneralType(Type object) {
    		this.object = object;
    	}
    	public Type getObj() {
    		return object;
    	}
    }
    public class Test01 {
    	public static void main(String[] args) {
    		GeneralType<Integer> i 
    					= new GeneralType<Integer>(2);
    		GeneralType<Double> d
    					= new GeneralType<Double>(0.33);
    		System.out.println("i.object=" + (Integer)i.getObj());
    //		System.out.println("d.object=" + (Integer)d.getObj();//编译错误
    	}
    }

使用generaltype时需要给出类型实参，根据类型实参确定泛型类中的属性的类型，方法处理的数据的类型，方法返回值的类型。

//泛型方法
    
    class GeneralMethod {
    	<Type> void printClassName(Type object) {
    		System.out.println(object.getClass().getName());
    	}
    }
    
    public class Test02 {
    	public static void main(String[] args) {
    		GeneralMethod gm = new GeneralMethod();
    		gm.printClassName("hello");
    		gm.printClassName(3);
    		gm.printClassName(3.0f);
    	}
    }

使方法所接收的参数或方法体处理的数据可定制，使用Type做类型参数，

使用通配符

public class GeneralType02<Type> {
    	Type object;
    	public GeneralType02(Type object) {
    		this.object = object;
    	}
    	public Type getObject() {
    		return object;
    	}
    	
    }
    public class ShowType02 {
    	public void show (GeneralType<?> o) {
    		System.out.println(o.getObj().getClass().getName());
    	}
    }
    public class Test03 {
    	public static void main(String[] args) {
    		ShowType02 st = new ShowType02();
    		GeneralType<Integer> i = new GeneralType<Integer> (2);
    		GeneralType<String> s = new GeneralType<String> ("HELLO");
    		st.show(i);
    		st.show(s);
    		
    	}
    }

有限制的泛型：在参数“Type”后使用“extends”关键字并加上类名或接口名，表明参数所代表的类型必须是该类的子类或实现了该接口。  
对于实现了某借口的有限制泛型，也是使用extends关键字，而不是implement关键字。

class GeneralType <Type extends Number> {...}

**8. 类的组合**

组合的语法：  
将已存在的类的对象放到新类中即可。

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

组合与继承的结合：

class Plate {
    	public Plate (int i) {
    		System.out.println("Plate constructor");
    	}
    }
    class DinnerPlate extends Plate {
    	public DinnerPlate (int i) {
    		super(i);
    		System.out.println("DinnerPlate constructor");
    	}
    }
    class Utensil {
    	Utensil(int i) {
    		System.out.println("Utensil constructor");
    	}
    }
    class Spoon extends Utensil {
    	public Spoon(int i) {
    		super(i);
    		System.out.println("Spoon constructor");
    	}
    }
    class Custom{
    	public Custom (int i) {
    		System.out.println("Custom constructor");
    	}
    }
    public class PlaceSetting extends Custom{
    	Spoon sp; DinnerPlate pl;
    	public PlaceSetting(int i) {
    		super (i+1);
    		sp = new Spoon(i+2);
    		pl = new DinnerPlate(i+3);
    		System.out.println("PlateSetting constructor");
    		
    	}
    	public static void main (String[] args) {
    		PlaceSetting x = new PlaceSetting(9);
    	}
    }

组合和继承都强调类的重用；前者强调包含关系，有一个，后者强调从属关系，是一个。构造复杂类的时候需要两者混用。

1.  类的重用机制：继承和组合；
2.  Object类的主要方法；
3.  终结类和终结方法的特点，语法
4.  抽象类和抽象方法的特点，语法