达内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修饰的
*方法：
（1）抽象方法：默认的访问修饰符public，可以省略abstract，
（2）普通方法：jdk1.8开始可以定义普通方法，用default / static修饰
}

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. 函数式接口
   接口中只有一个抽象方法 --> lambda表达式

接口和抽象类的区别

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

3. 内部类

1. 类体内部类

package cn.tedu.inner;
/**
*没有static修饰的内部类
*/
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;
/**
*有static修饰的内部类
*/
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);
	}
}

总结：匿名类

1. 可以继承父类
2. 可以实现接口
3. 可以创建对象
4. 语法格式：父类类型（接口类型） 变量名 = new 父类类型（接口类型）（）{
   匿名类类体；
   }