达内javaSE_day07 学习笔记 —— 关键字（abstract，interface）、内部类

javaSE_day07

1. 关键字

1.1 abstract

• 抽象方法：

  • 由abstract修饰的方法
  • 特点：没有方法体

• 抽象类：

  • 由abstract修饰的类 —— 模板
  • 特点：不能实例化（创建对象）

• 抽象类中可以没有抽象方法

• 抽象类由子类创建对象

• 子类可以创建对象，必须实现所有的抽象方法

• 如果没有实现全部的抽象方法，当前类还得声明为抽象类。

eg:

练习：
定义一个类表示形状，提供获取周长和面积的方法， 然后给这个类提供子类：矩形 - 正方形，椭圆 - 圆形

• 1)定义抽象类Shape，两个抽象方法double getArea()和double getLength()
• 2）定义子类Rectangle，（构造方法传参）
• 3）定义子类Oval，（构造方法传参）
  周长：PI * a * b ，面积：2* PI * b+4(a-b)
• 4）定义Rectangle的子类Square
• 5）定义Oval的子类Circle
• 6）测试：计算各种图形的面积周长
  

1.2 interface

1.2.1 定义接口

interface 接口名{
*变量：int x = 10; // public static final修饰的
*方法：jdk1.8之前 特点：
（1）抽象方法，可以省略abstract，
（2）默认的访问修饰符public
* void f();
}

1.2.2 使用接口 implements

• 实现接口的类，必须实现接口中的所有方法，才可以创建对象。
• 如果不实现接口中的所有方法，那么当前类必须为abstract的类
  

1.2.3 接口和接口之间是继承关系

interface A{}
Interface B extends A{}

1.2.4 类和接口之间是实现关系，可以实现多个接口

class Demo extends Demo2 implements B,C{}

练习：

1. 利用接口做参数，写个计算器，能完成加减乘除运算。

   （1）定义一个接口ICompute
   含有一个方法int computer(int n, int m)。

   （2）设计四个类Add,Sub, Mul,Div分别实现此接口，
   完成加减乘除运算。

   （3）设计一个类UseCompute，
   类中含有方法：
   public void useCom(ICompute com, int one, int two)，
   此方法能够用传递过来的对象调用computer方法完成运算，
   并输出运算的结果。

   （4）设计一个主类Test，
   调用UseCompute中的方法useCom来完成加减乘除运算。
   

2. 按如下要求编写Java程序：

   （1）定义接口A，里面包含值为3.14的常量PI和
   抽象方法double doubleArea(double radius)。//πr*r

   （2）定义接口B，里面包含
   抽象方法void setColor(String c)。

   （3）定义接口C，该接口继承了接口A和B，
   里面包含抽象方法
   void volume(double radius,double height)//πrrh

   （4）定义圆柱体类Cylinder实现接口C
   

接口jdk1.8新特性

1. 接口中可以定义普通方法
   

2. default修饰的方法由实现类调用
   Static修饰的方法可以由接口名直接调用
   接口不能创建对象
   

3. 实现类的接口和父类定义了同名方法，如何访问？
   访问父类的方法
   

4. 如果两个接口中都定义了同名方法，如何访问？
   出现编译错误，子类必须重写同名方法。
   

5. 函数式接口
   接口中只有一个抽象方法

接口和抽象类的区别

	抽象类	接口
1.	模板类	不同类型的公共的行为（规范JDBC）
2.	不能多继承	可以多继承
3.	有构造方法	没有构造方法
4.	变量是普通的变量	都是静态常量
5.	普通方法	普通方法由default / static修饰
6.	抽象方法没有默认访问修饰符	访问修饰符是public

3. 内部类

1. 类体内部类

package cn.tedu.inner;
/**
*类体内部普通类
*/
public class Demo1 {

	public int x;  //变量
	public static int y; //静态变量	
	
	class Inner{  //类成员  可节省内存   可以用private、static修饰
		int a;
		//static int b; //不可以定义静态成员,但可以定义静态常量
		final static int b = 0; 
		void test3() {
			x = 0; //可以访问外部类的成员
			y = 1;
			System.out.println("test3");
		}
	}	
	
	public static void test2() { //静态方法
		System.out.println("test2");
	}
	public void test() { 
		System.out.println("test");
	}
	
	public static void main(String[] args) {

		Demo1.Inner inner = new Demo1().new Inner();//创建内部类对象
		inner.test3();
	}
}

package cn.tedu.inner;
/**
*类体内部静态类
*/
public class Demo2 {
	public int x;  //变量
	public static int y; //静态变量		
	
	static class Inner{
		int a = 0;
		static int b = 9;//可以定义静态成员和非静态成员
		void f() {
			//x = 0; //error
			y = 1;//可以访问外部静态成员
			System.out.println("test3");
		}
	}
	
	void test() { 
		System.out.println("test");
	}

	static void test2() { //静态方法
		System.out.println("test2");
	}
	
	public static void main(String[] args) {
		Demo2.Inner inner = new Demo2.Inner();  //静态方法不用创建对象  直接 类名.方法
		inner.f();
	}
}

2. 方法内的内部类

package cn.tedu.inner;
/**
*方法内的内部类
*/
public class Demo3 {

	public int x;  //变量
	public static int y; //静态变量		
	void f() {
		//方法内的变量被内部类访问后，变量被标识为常量  a
		int a = 0;//不能被private、static修饰     变量a
		
		class Inner{ //不能被private、static修饰      （属于方法内的局部变量）
			int b = 0;  //jdk1.7之后默认为常量
			//static int c = 0;//error 
			final static int c = 0;//不可以定义静态成员,但可以定义静态常量
			void f() {
				x = 0;//可以访问外部类的成员（静态、非静态）
				y = 0;
				
				//a = 0;//error  常量不能修改   内部类访问方法内的变量时被标识为为常量
				int r = a+0;
				
				System.out.println("!!!");
			}
		}
		new Inner().f();
	}
	public static void main(String[] args) {
		new Demo3().f();
	}
}

3. 匿名类

package cn.tedu.inner;
/**
 *  匿名类
 */
public class Demo4 {
	Object obj = new Object() {
		//创建子类的对象
		@Override
		public String toString() {
			return "helllo";
		}
	};
	IDemo demo = new IDemo() {
		@Override
		public void f() {
			System.out.println("接口的实现");			
		}  
	};			
	
	public void test(IDemo demo) {
		demo.f();
	}
	public static void main(String[] args) {
		//静态方法不能直接访问实例成员，要new
		//System.out.println(new Demo4().obj.toString());  
		//new Demo4().demo.f();
		new Demo4().test(new IDemo() {		
			public void f() {
				System.out.println("!!!!");
			}
		});
		
		Demo4 demo4 = new Demo4();
		demo4.test(demo4.demo);
	}
}