笔记16 抽象类和内部类

package test0909;

public  class AbstractClassTest {
/*
 * 		1、抽象类
 * 			1) 它必须用 abstract 关键字修饰。
 * 			2) 抽象类不能实例化（即：不能创建对象）。
 * 			3) 抽象类必须被继承（即：必须有子类）且子类中对继承来的所有抽象方法必须重写。
 * 			否则子类也是抽象的。
 * 
 * 		2、什么是抽象方法？
 * 			只有方法的头部，没有方法体的方法称之为抽象方法。
 * 			理解：此方法只知道做什么，不知道如何做。
 * 		
 * 			注意: 抽象方法的头部必须添加一个 abstract 关键字修饰它。
 * 			例如: public abstract int add( int x, int y ) ; 
 * 
 * 			因此，如何一个类中包含了抽象方法，则该类必须是抽象类。
 * 
 * 			注意: 抽象类一定包含了抽象方法吗？
 * 				 答案: 不一定。
 * 
 * 		3、最终类
 * 			1) 它必须由 final 修饰。
 * 			2) 最终类不能有子类（防继承）。
 * 
 * 		4、最终方法
 * 			1) 它必须由 final 修饰。
 * 			2) 它不可被重写（防重写）。 
 */
	public static void main(String[] args) {
		Person  p1 = new SubStudent();  //new Student(); //new Person();	
	}
}

abstract  class  Person {
	private String name;
	private boolean sex;
	private int age;
	
	public Person() {
	}
	
	//抽象的方法。
	public abstract int add( int x, int y ); 
	
	public abstract int sub( int x, int y );
	
	public final void  showMessage( String info ){		//最终方法；
		System.out.println("用户给定的信息是: " + info );
	}
}

abstract  class  Student  extends Person {
	@Override
	public int add(int x, int y) {
		return x + y;
	}
	
//		public void showMessage(String info) {		//最终方法不能被重写；
//			System.out.println( info );
//		}	
}

class  SubStudent  extends  Student {
	
	public int sub(int x, int y) {
		return x - y;
	}
}

//class  Sub1 extends  String  {				//String为最终类，不可被继承；
//}

final class FinalFather {
	
}
//class  Son extends  FinalFather {				//最终类不能被继承；
//}

 

package test0909;

/*
 * 		1、内部类
 * 			包含在一个类的类体中的类。
 * 
 * 		2、外部类
 * 			包含了内部类的类。
 * 
 * 		3、在内部类的方法中是否可以直接访问外部类的成员？
 * 			答案: 可以。
 * 
 * 		4、在外部类的方法中是否可以直接访问内部类的成员？
 * 			答案: 不可直接访问。
 * 		如何访问？
 * 			答案: 先创建内部类的对象， 再通过此对象去访问内部类的成员。
 * 
 * 		5、在外部类之外的类中如何访问内部类的成员？
 * 			1) 先创建外部类的对象。
 * 			2) 再通过外部类的对象去创建一个内部类的对象。
 * 			3) 最后通过内部类的对象去访问其成员。
 * 
 * 		例如: 有一个外部类为A，内部类为B；且有method()方法为内部类B的方法。
 * 			1) A  aObj = new  A();
 * 			2) A.B  bObj = aObj.new  B();
 * 			3) bObj.method();
 * 
 * 		6、什么匿名的内部类？
 * 			没有名称的内部类。
 * 
 * 		7、如何生成一个匿名的内部类？
 * 			在构造某个类的对象时，在其构造器的末尾添加一对大括号；
 * 		
 * 			然而，在这一对大括号中重写该类的某个或某几个方法所生成的一段代码。
 */
public class InnerClassTest {
	static int x = 10;
	static MyArithmetic  obj =  new MyArithmetic(){		//匿名的内部类
		@Override
		public int add(int x, int y) {
			System.out.print( x + " + " + y + " = " );
			return x + y ;
		}
	};
	
	public static void main(String[] args) {
		System.out.println( "x = " + x );
	
		System.out.println(  obj.add(10, 20) );
		
		System.out.println( 
			new MyArithmetic(){							//匿名的内部类
				@Override
				public int add(int x, int y) {
					System.out.print( "====>>>" + x + " + " + y + " = ");
					return x + y;
				}
			}.add( 100 , 200 ) 		
		);
		
		MyMath  mm = new  MyMath(){ 					//匿名的内部类
			@Override
			public double div(int x, int y) {
				System.out.print("\n\n" + x + " / " + y + " = ");
				return x * 1.0 / y ;
			}
			
			@Override
			public void showinfo(String info) {
				System.out.println( info );
			}
		};
		
		double result = mm.div( 5 , 2  );
		System.out.println( result );
		
		mm.showinfo("I love java!");
	}
}


abstract class  MyArithmetic {
	public abstract int add( int x, int y );
}

interface  MyMath {
	double div( int x, int y );
	void showinfo( String info );
}