高级类特性

说了开始复习基础了，虽然以前也做过笔记，而且现在属于复习，在考虑是否还要写笔记包括blog是否要写这些东西，想了好久，还是写写吧，不然一天干了什么都不知道..

 

抽象类

• 在定义java方法时可以只给出方法头，而不必给出方法体，即方法实现的细节，这样的方法被称为抽象方法。
• 抽象方法必须使用关键字abstract修饰，包含抽象方法的类必须声明为抽象类。
• java语法规定，子类必须实现父类中的所有抽象方法，否则改子类也只能声明为抽象类。
• 抽象类不能被实例化。

 

public abstract class Animal
{
	private int age;
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public abstract void eat();
}

 

public class Person extends Animal
{
	private String name;
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void eat(){
	//重写方法
		System.out.println("洗手--做饭--吃饭--收拾");
	}
}

 

public class Test
{
	public static void main(String[] args){
	Animal a=new Person();//正确
	//Animal a=new Animal(); 错误
		a.setAge(2);
		a.eat();
	}
}

 抽象类主要是通过继承、再由其子类发挥作用的，其中作用包括两方面：

• 代码的重用
• 规划

其他特性：

• 抽象类中可以不包含抽象方法;
• 子类中可以不全部实现抽象父类中的抽象方法，但是此时子类也只能声明为抽象类;
• 父类不是抽象类，但在子类中可以添加抽象方法，但子类需声明为抽象类;
• 抽象类中可以声明static属性和方法

接口

• 接口(interface)是抽象方法和常量值的定义的集合。
• 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

public interface Runner
{
	public static final int id=1;
	public abstract void start();
	public abstract void run();
	public abstract void stop();
}

•  接口中定义的属性必须是public static final的，而接口中定义的方法则必须是public abstract的，因此这些修饰符可以是部分或全部

public interface Runner
{
	public static final int id=1;
	public abstract void start();
	public abstract void run();
	public abstract void stop();
}

 等价于------------------------------------------------->

public interface Runner
{
	int id=1;
	void start();
	void run();
	void stop();
}

•  和继承关系类似，java类可以"实现"接口，且接口和实现类之间也存在多态性。

[<modifier>] class <name> [extends <superclass>]
[implements <interface> [,<interface>]*]{
	declarations>*
}

 

public class Person implements Runner
{
	public void start(){
		System.out.println("弯腰,准备,开跑");
	}
	public void run(){
		System.out.println("加速冲向终点");
	}
	public void stop(){
		System.out.println("胜利，休息");
	}
}

 

public class Test
{
	public static void main(String[] args){
		Runner r=new Person();
		r.start();
		r.run();
		r.stop();
	}
}

•  接口的多重实现

interface Runner{
	public void run();
}

interface Swimmer{
	public void swim();
}

abstract class Animal{
	public abstract void eat();
}

class Person extends Animal implements Runner,Swimmer
{
	public void run(){
		System.out.println("I am runing");
	}
	public void swim(){
		System.out.println("I am Swimming");
	}
	public void eat(){
		System.out.println("I am eating");
	}
}

public class Test{
	public static void main(String[] args){
		Test t=new Test();
		Person p=new Person();
		t.m1(p);
		t.m2(p);
		t.m3(p);
	}
	public void m1(Runner f){
		f.run();
	}
	public void m2(Swimmer s){
		s.swim();
	}
	public void m3(Animal a){
		a.eat();
	}
}

 输出结果：

I am running

I am swimming

I am eating

接口间的继承

interface A{
	public void ma();
}
interface B{
	public int mb(int i)
}
interface C extends A,B{
	public String mc();
}
class D implements C{
	public void ma(){
		System.out.println("Implements method ma()");
	}
	public int mb(int i){
		return 2000+i;
	}
	public String mc(){
		return "Hello";
	}
}

 接口特性总结

• 通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系；
• 接口可以被多重实现
• 接口可以继承其它的接口，并添加新的属性和抽象方法，接口间支撑多重继承

嵌套类

java语言支持类的嵌套定义，即允许将一个类定义在其他类的内部，其中内层的类被称为嵌套类(Nested Class)

嵌套类可以分为两种：

• 静态嵌套类(Static Nested Class):使用static修饰的嵌套类;
• 内部类(Inner Class):非static的嵌套类

public class A{
	...
	private class B{	//内部类
		...
	}
	public static class C{	//静态嵌套类
		...
	}
}

内部类又可分为三种情况:

1. 普通的内部类:在java类中、方法或语句块的外部定义的非static类。 
2. 局部内部类:也称局部类(Local Class),定义在方法或语句块中的类
3. 匿名内部类:也称匿名类(AnonymousClass),定义在方法或语句块中，该类没有名字.只能在其所在之处使用一次

• 内部类与其所在的外层类之间存在着逻辑上的依赖关系——内部类的对象不能单独存在，它必须依赖一个其外层类的对象;
• 在内部类中可以直接访问其外层类中的成员、包括属性和方法，即使在这些属性和方法是private的
• 内部类可以声明为抽象类，因此可以被其它的内部类继承，也可以声明为final的
• 和外层类不同，内部类可以声明为private或protected。

public class A{
	private int s;
	private class B{
		public void mb(){
			s=100;	
			System.out.println("在内部类B中S="+s);
		}
	}
	public void ma(){
		B i=new B()	
		i.mb();
	}
}

public class TestInner{
	public static void main(String[] args){
		A o=new A();	
		o.ma();
	}
}

•  在外部使用其他类中的内部类时，应指明起完整层次，并显示建立对象间的依赖关系。

public class A{
	private int s;
	private class B{
		public void mb(){
			System.out.println(s);
		}
	}
}

public class TestInner2{
	public static void main(String[] args){
		A a=new A();
		//创建一个依赖于a而存在的b
		A.B b=a.new B();
		b.mb();
	}
}

•  内部类中出现变量名冲突时，可以使用内部类对象的特殊性"<外层类名>.this"来访问其所依赖外层类对象的成员.

class A{
	private int s=111;
	private class B{
		private int s=222;
		public void mb(int s){
			System.out.println(s);//局部变量s
			System.out.println(this.s);//内部类对象的属性s
			System.out.println(A.this.s);//外层类对象属性s
		}
	}
}

public class TestInner3{
	public static void main(String[] args){
		A a=new A();
		A.B b=a.new B();
		b.mb(333);
	}
}

枚举类型

• Java SE5.0开始，java语言引入了一种新的引用数据结构——枚举(Enum).
• Java 语言中枚举类型均自动继承了java.lang.Enum类(该类继承了Object类).
• 枚举类型使用一组常量值来表示特定的数据集合，改集合中数据的数目确定(通常较少),且这些数据只能取预先定义的值。

public enum Week{
	Mon,Tue,Wed,Thu,Fri,Sat,Sun
}

public class TestEnum{
	public static void main(String[] args){
		TestEnum te=new TestEnum();
		te.work(Week.Sun);
	}
	public void work(Week day){
		if(day.equals(Week.Sat)){
			System.out.println("shopping");
		}else if(day.equals(Week.Sun)){
			System.out.println("sleep");
		}else{
			System.out.println("work");
		}
	}
}