java - 类

package tdx;

class C1 {
	public int c1;
	public C2 c2;
	
	public C1(int c1, C2 c2) {
		this.c1 = c1;
		this.c2 = c2;
	}
	
	public void Print() {
		System.out.println(this.c1);
	}
}

class C2 {
	public int c2;
	public C1 c1;
	
	public C2(int c2, C1 c1) {
		this.c1 = c1;
		this.c2 = c2;
	}
	
	public void Print() {
		System.out.println(this.c2);
	}
}

public class ClassTest {

	public static void main(String[] args) {
		
		C1 c1 = null;
		C2 c2 = new C2(2, c1);
		c1 = new C1(1, c2);
		
		c2.Print();
		c1.Print();
		c1.c2.Print();
		c2.c1 = c1;
		c2.c1.Print();
	}
}

// output
2
1
2
1

像C++中变量的定义一样，关键字 class 定义一个类，然后 C1 c1 = null;   在内存中应该和C++中类似。变量 c1 占据了一个4B大小的空间，它的值存放的是null值，就是空值。但是 c1 的类型为类C1。所以在 C2 的构造函数中入参c1没有问题。

类

类分为抽象类和一般类。

抽象类与一般类的区别：

1. 抽象类中有抽象方法，就是没有被实现的方法，类似与接口。普通类中的所有方法都必须实现。

2. 抽象类不能被单独实例化。

抽象类定义：

// 抽象类
public abstract class AbsCls {
  
  // 可以定义静态变量和方法
  // 这里的静态变量和方法都必须是非抽象的
  public static final int num = 0;       // 也可以定义成 private 类型
  // public static abstract void Print();   //error 不能定义静态的抽象方法
  
  // 可以不用在抽象类中定义抽象方法
  // 如果没有定义抽象方法，这时这个抽象类就和普通类一样，但是不能被单独实例化
  public abstract void aPrint();
}

2015-05-29

关于抽象类不能被单独实例化，但是在代码中经常可以看到这样的用法。

package test.abs;

abstract class abs {
	public abstract void Print();
}

public class AbstractClassTest {

	public static void main(String[] args) {
		
		abs a = new abs() {
			@Override
			public void Print() {
				System.out.println("hello world");
			}
		};
		
		a.Print();
	}
}

这里可以看到，程序不会报错。同时也会输入： hello world

接口

接口的作用是什么，是抽象。抽象出统一的方法，然后让具体的类去实现。

接口和抽象类的区别： 

1. 接口和抽象类都可以自己实现函数，对于接口，实现的函数必须加 static 关键字，即将方法声明为静态方法；抽象类则不用 static 关键字。

package test.cls;

interface its {
	
	public static void uPrint() {
		System.out.println("its uPrint");
	}
	
	public void iPrint();
}

abstract class abs {
	
	public static void sPrint() {
		System.out.println("abs sPrint");
	}
	
	public void uPrint() {
		System.out.println("abs uPrint");
	}
	
	public abstract void iPrint();
}

class cls1 extends abs {
	
	public void iPrint() {
		System.out.println("abs iPrint");
	}
}

class cls2 implements its {
	
	public void iPrint() {
		System.out.println("its iPrint");
	}
}

public class ClassTest {
	
	public static void main(String[] args) {
		
		cls1 c1 = new cls1();
		cls2 c2 = new cls2();
		
		c1.iPrint();
		c2.iPrint();
		
		c1.uPrint();
//		try {
//			c2.uPrint();
//		} catch(Exception e) {
//			e.printStackTrace();
//		}
		
		c1.sPrint();
	}
}

/*
  输出：
  abs iPrint
  its iPrint
  abs uPrint
  abs sPrint
  其中 c2.uPrint(); 这句话会有语法错误
*/

可以看到，抽象类定义实现的方法(不管是 static 还是 public 方法)，都可以在子类中使用。而对于接口来说，其只能实现静态方法，并且不能被其实现类使用。

接口和抽象类的共同点：

1. 他们中定义的接口方法或者是抽象方法都必须在子类中实现，不能只实现一部分。

所以理想的模型是这样的：

接口抽象方法 --> 抽象类去实现接口  --> 一个默认实现类  --> 你的实现类

package test.cls;

interface its {
	
	public void iPrint();
	public void uPrint();
}

abstract class abs implements its {
	
	public void iPrint() {
		System.out.println("this is abs iPrint");
	}
	
	public abstract void uPrint();
}

class dfcls extends abs {
	
	public void uPrint() {
		System.out.println("this is a default uPrint");
	}
}

class cls extends dfcls {
	
	@Override
	public void uPrint() {
		System.out.println("this is a redefined uPrint");
	}
}

public class ClassTest {
	
	public static void main(String[] args) {
		
		cls c = new cls();
		c.iPrint();
		c.uPrint();
	}
}

/*
  输出：
  this is abs iPrint
  this is a redefined uPrint
*/