复用类-继承、组合、代理

 一  综述

     1.toStirng方法

     2.继承

     3.组合

     4.代理

     

二 分别解释

     1. toString方法，每一个非基本类型都有一个toString方法，当编译器需要一个toString，而你只有一个对象时，这个方法就会被调用。

     

public class Demo2 {
	private String name;

	public Demo2(String name) {
		this.name = name;
	}

	public String toString() {
		return "I am " + name;
	}

	public static void main(String[] args) {
		System.out.println(new Demo2("jack"));
	}
}
结果：I am jack

     2.继承：子类继承父类的特征，主要说一下protected。

        访问权限修饰符分别为：public、protected、默认的、private这个四个。首先public在同一个类中、同一个包中。同一个工程下面、不同的工程下面都可以访问。所谓权限大大的。protected在同一个package下面可以随便的访问，还有一个特殊的就是在继承的子类中可以访问。例如Father父类，Father类中有一个protected修饰的age方法，Son继承了Father（Son可以和Father不在一个package下面，不在一个工程下面不可以），默认实在同一个package下面可以访问，private只能在当前类中访问。

        权限修饰符主要的作用就是为了隐藏底层的内部实现，我自己理解不知道对不对！例如我做了一个求和的方法，

	public int getSum(int from, int to) {
		return get(from,to);
	}

	private int get(int from, int to) {
		return (from + to) * (from - to + 1) / 2;
	}

     调用getSum就会得到一个区间的和，对外只提供了结果，而隐藏了内部的实现，当研发人员发现更好地实现方法实现求和时，只需要更改get方法即可。外部的调用仍然通过getSum获得结果。

          

     protected实例我是在同一个包下面的！        

class Vill {
	private String name;

	protected void set(String name) {
		this.name = name;
	}

	public Vill(String name) {
		this.name = name;
		System.out.println("father...");
	}

	public String toString() {
		return " i am " + name;
	}
}

public class VillExtends extends Vill {
	private int age;

	public VillExtends(String name, int age) {
		super(name);
		this.age = age;
	}

	public void f(String name, int age) {
		set(name);
		this.age = age;
	}

	public String toString() {
		return age + super.toString();
	}

	public static void main(String[] args) {
		VillExtends v = new VillExtends("aa", 11);
		System.out.println(v);
		v.f("jack", 33);
        System.out.println(v);
	}

           protected就用户类而言，这是private的，而对于继承它的类而言是public 的。如果还有一个类Demo和villExtends在一个包下面，而和vill不在同一个包下面，那么vill的set方法相对于Demo类而言就是private，而对于villExtends而言就是public的。

      3.组合：一个在一个类中定义了另一个类的对象！这个就不详细说了

    4.组合和继承的关系：

         (1).如果存在一种IS-A的关系，并且一个类需要向另一个类暴露所有的方法接口，那么更应该用继承的机制。  

        (2).如果存在一种HAS-A的关系，那么更应该运用组合。

    5.代理：在一个类中创建另一个类的对象，以获取这个类的部分方法！

    

//上下左右移动
public class Demo4 {
	public void r() {
		System.out.println("right");
	}

	public void l() {
		System.out.println("left");
	}

	public void d() {
		System.out.println("down");
	}

	public void u() {
		System.out.println("up");
	}
}

//左右移动 飞
public class Demo5 {
	private Demo4 d = new Demo4();

	public void l() {
		d.l();
	}

	public void r() {
		d.r();
	}

	public void fly() {
		System.out.println("fly");
	}
}

     类 Demo5拥有所有Demo4所有方法，但是 Demo5相对比与继承，Demo5拥有更多的控制力，可以选择自己想要的方法！

 

  补充1：    

package com.demo.one;

public class Demo05 {
	public static void main(String[] args) {
		new Circle();
	}
}

class Draw {
	static {
		System.out.println("jiazai Draw");
	}

	public Draw(String type) {
		System.out.println(type + " draw constructor");
	}
}

class Shape {
	private Draw draw = new Draw("shape");
	static {
		System.out.println("jiazai Shape");
	}

	public Shape() {
		System.out.println("shape constructor");
	}
}

class Circle extends Shape {

	private Draw draw = new Draw("circle");
	static {
		System.out.println("jiazai Circle");
	}

	public Circle() {
		System.out.println("circle constructor");
	}
}
结果：
jiazai Shape
jiazai Circle
jiazai Draw
shape draw constructor
shape constructor
circle draw constructor
circle constructor

    加载上面类的过程：Demo05 Shape CircleDraw。入口函数 父类 子类 初始化调用类只是很单纯的加载了类，调用了类的方法。

  初始化的过程和类的加载过程是不一样的。什么时候初始化什么时候调用相应的构造方法。

  两个特殊的静态方法不需要初始化对象就能调用的：main、构造方法都是用static修饰的。

补充2:摘抄地址：http://www.cnblogs.com/dolphin0520/p/3803432.html

public class Test {
    public static void main(String[] args)  {
        Shape shape = new Circle();
        System.out.println(shape.name);
        shape.printType();
        shape.printName();
    }
}
 
class Shape {
    public String name = "shape";
     
    public Shape(){
        System.out.println("shape constructor");
    }
     
    public void printType() {
        System.out.println("this is shape");
    }
     
    public static void printName() {
        System.out.println("shape");
    }
}
 
class Circle extends Shape {
    /覆盖
    public String name = "circle";
     
    public Circle() {
        System.out.println("circle constructor");
    }
     //覆盖
    public void printType() {
        System.out.println("this is circle");
    }
    //隐藏
    public static void printName() {
        System.out.println("circle");
    }
}
结果：
shape constructor
circle constructor
shape
this is circle
shape

   　 　覆盖只针对非静态方法（终态方法不能被继承，所以就存在覆盖一说了），而隐藏是针对成员变量和静态方法的。这2者之间的区别是：覆盖受RTTI（Runtime type  identification）约束的，而隐藏却不受该约束。也就是说只有覆盖方法才会进行动态绑定，而隐藏是不会发生动态绑定的。在Java中，除了static方法和final方法，其他所有的方法都是动态绑定。因此，就会出现上面的输出结果。

   

    如果问题还望多多指教！每天进步一丢丢！！！