泛型类、多参数泛型类、泛型接口（2）、静态非静态泛型函数、泛型绑定类

转自 harvic慢跑的乌龟 http://blog.csdn.net/harvic880925/article/details/49872903 

Point

package com.example.genericdemo;

/**
 * 1、泛型类 你传进去的是什么，T就代表什么类型
 */
class Point<T> {// 此处可以随便写标识符号
	private T x;
	private T y;

	public void setX(T x) {// 作为参数
		this.x = x;
	}

	public void setY(T y) {
		this.y = y;
	}

	public T getX() {// 作为返回值
		return this.x;
	}

	public T getY() {
		return this.y;
	}
}

/**
 * 2、多参数泛型类
 */
class MorePoint<T, U> {
	private T x;

	private U name;

	public void setX(T x) {
		this.x = x;
	}

	public T getX() {
		return this.x;
	}

	public void setName(U name) {
		this.name = name;
	}

	public U getName() {
		return this.name;
	}
}

/**
 * 3、1泛型接口
 */
interface Info<T> { // 在接口上定义泛型
	public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型

	public void setVar(T var);
}

class InfoImpl<T> implements Info<T> { // 定义泛型接口的子类
	private T var; // 定义属性

	public InfoImpl(T var) { // 通过构造方法设置属性内容
		this.setVar(var);
	}

	public void setVar(T var) {
		this.var = var;
	}

	public T getVar() {
		return this.var;
	}
}

/**
 * 3、2泛型接口
 */

class InfoImpl1 implements Info<String> { // 定义泛型接口的子类
	private String var; // 定义属性

	public InfoImpl1(String var) { // 通过构造方法设置属性内容
		this.setVar(var);
	}

	@Override
	public void setVar(String var) {
		this.var = var;
	}

	@Override
	public String getVar() {
		return this.var;
	}
}

Fruit

package com.example.genericdemo;

/**
 * 4.3泛型绑定类 就可以限定填充的变量必须派生自Fruit的子类
 * 
 */
class Fruit {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

class Banana extends Fruit {
	public Banana() {
		setName("bababa");
	}
}

class Apple extends Fruit {
	public Apple() {
		setName("apple");
	}
}

MainActivity

package com.example.genericdemo;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		/**
		 * 1、泛型类
		 */
		Point<Integer> p = new Point<Integer>();
		p.setX(new Integer(100));
		Log.e("TAG", "p.getX()==" + p.getX());
		/**
		 * 2、多参数泛型类
		 */
		MorePoint<Integer, String> morePoint = new MorePoint<Integer, String>();
		morePoint.setName("harvic");
		morePoint.setX(new Integer(100));
		Log.e("TAG", "morPont.getName==" + morePoint.getName()
				+ ",morePoint.getX()==" + morePoint.getX());

		/**
		 * 3、1泛型接口
		 */

		InfoImpl<String> i = new InfoImpl<String>("asffafsfgg");
		System.out.println(i.getVar());
		Log.e("TAG", "" + i.getVar());

		/**
		 * 3.2泛型接口
		 */
		InfoImpl1 i1 = new InfoImpl1("sfasfa");
		Log.e("TAG", "" + i1.getVar());

		/**
		 * 4.1静态泛型函数,返回值前加上<T>来表示泛型变量 函数里所有用到的T类型也就是强制指定了是String类型
		 */
		MainActivity.<String> StaticMethod("AAAAA");
		MainActivity.StaticMethod("AAAAA");
		/**
		 * 4.2非静态泛型函数
		 */
		MainActivity.this.<Integer> OtherMethod(new Integer(123));
		MainActivity.this.OtherMethod(new Integer(123));

		/**
		 * 4.3泛型绑定类 就可以限定填充的变量必须派生自Fruit的子类
		 */
		String name_1 = getFruitName(new Banana());
		String name_2 = getFruitName(new Apple());
		Log.e("TAG", name_1);
		Log.e("TAG", name_2);

	}

	public static <T extends Fruit> String getFruitName(T t) {
		return t.getName();
	}

	public static <T> void StaticMethod(T a) {
		Log.e("TAG", "StaticMethod: " + a.toString());
	}

	public <T> void OtherMethod(T a) {
		Log.e("TAG", "OtherMethod: " + a.toString());
	}
}