阅读数:155 评论数:0

一、类的继承

1、说明

（1）extends关键字用于类的继承。

（2）在C++中，方法的动态绑定是使用virtual关键字来实现的，而在Java中，动态绑定是默认的形为，不需要添加额外的关键字。

（3）子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。

（4）使用关键字super显式调用基类的构造器。

2、示例

//c++代码
class Base{
public :
	Base(){init();}
	virtual ~Base(){}
protected:
	virtual void init()
	{
		cout<<"in Base::init()"<<endl;
	}	
};
class Derived:public Base{
public:
	Derived(){init();}
protected:
	void init(){
		cout<<"in Derived::init()"<<endl;
	}
};
int main(int argc,char* argv[]){
	Base *pb;
	pb = new Derived();
	delete pb;
	return 0;
}
/*
执行结果：
in Base::init()
in Derived::init()
*/

//java
class Base{
	public Base(){init();}
	protected void init(){
		System.out.println("in Base::init()");
	}
}
class Derived extends Base{
	public Derived(){init();}
	protected void init(){
		System.out.println("in Derived::init");
	}
}
public class Test{
	public static void main(String[] args){
		Base base = new Derived();
	}
}
/*
执行结果 ：
in Derived::init()
in Derived::init()
这是因为Java中的类对象在构造前就已经存在了，而c++中只有在构造完毕后才存在。
*/

二、final关键字

1、说明

（1）修饰类，此为不可被继承

（2）修饰方法，方法不可被覆盖。类中所有的private方法都隐式地指定为final。

（3）修饰变量时，只能在定义或构造函数中被赋值一次。对于基本类型，final可以使其成为编译常量。对于对象引用，一旦被指向一个对象，就不能再改为指向另一个对象。

2、示例

public class Bat{
	final double PI = 3.14;//在定义时赋值
	final int i;
	final List<Bat> list;
	Bat(){
		i = 100;
		list = new LinkedList<Bat>();
	}
	Bat(int ii,list<Bat> l){
		i = ii;
		list = l;
	}
	public static void main(String[] args){
		Bat b = new Bat();
		b.list.add(new Bat());
		//b.i = 25;
		//b.list = new ArrayList<Bat>();
	}
}

三、接口

1、说明

（1）用interface关键字创建一个接口，要让一个类实现特定接口，需要使用implements关键字。

（2）接口也可以包含域，但是这些域隐式是static和final的。

2、示例

interface Runner//定义接口
{
	int i = 3;
	public void start();
	void run();
	void stop();
}
interface Eater extends Runner//接口间可以继承
{
	public final static int j = 4;
	void openMouth();
	void upAndDown();
	void goIn();
}
class TT implements Eater//实现接口
{
	public void start(){System.out.println("start");}
	public void run(){System.out.println("run");}
	public void stop(){System.out.println("stop");}
	public void openMouth(){System.out.println("openMouth");}
	public void upAndDown(){System.out.println("upAndDown");}
	public void goIn(){System.out.println("goIn");}
}
public class TestInterface {
	public static void main(String[] args){
		Runner tt = new TT();
		System.out.println(tt.i);
		System.out.println(Runner.i);
		tt.start();
		Eater ee = new TT();
		System.out.println(ee.j);
		System.out.println(Eater.j);
		ee.start();
	}
}

四、内部类

1、说明

在一个类中定义另外一个类，这个类就叫做内部类。

（1）它能访问其外围对象的所有成员。

（2）如果你需要生成对外部类对象的引用，可以使用外部类的名字后面紧跟.this.

（3）使用.new创建内部类的引用

2、内部静态类

外部类可以访问内部类的所有方法与属性，包括private修饰的。

（1）非静态内部类能够访问外部类的静态和非静态成员。静态内部类不能访问外部类的非静态成员，

（2）非静态内部类不能有static数据，只能放在外部类中。静态内部类可以包含所有东西。

3、示例

public Class Test(){
	private int num;
	public Test(int num){ this.num = num;}
	private Class Inner{
		public Test getTest(){
			return Test.this;
		}
		public Test newTest(){
			return new Test();
		}
	}
	public static void main(String[] args){
		Test test = new Test(5);
		Test.Inner inner = test.new Inner();
		Test test2 = inner.getTest();
		Test test3 = inner.newTest();
		System.out.println(test2.num);
		System.out.println(test3.num);
	}
}
/**
执行结果:
5 0
*/

五、函数重载

当函数同名时，只看参数表，和返回值类型没关系。

六、abstract

1、说明

（1）抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰。

（2）abstract不可以与final ， private , static共存。

（3）一个类中如果有抽象方法，则这个类必须是抽象类。

（4）抽象类中可以没有抽象方法。

（5）抽象类是不能存在实例对象的，就是为了被继承而存在的。