`
fehly
  • 浏览: 248421 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

高级类特性

    博客分类:
  • java
阅读更多

说了开始复习基础了,虽然以前也做过笔记,而且现在属于复习,在考虑是否还要写笔记包括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");
		}
	}
}

 

 

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics