学习Java第十六天

Java多态（下）

接口

接口定义了某一批类所要遵守的规范，接口不关心这些类的内部数据，页不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法

语法：
[修饰符] interface 接口名 [ extends 父接口1,父接口2...]
{
     零到多个常量定义...
     零到多个抽象方法的定义...
     零到多个默认方法的定义...(JDK1.8新增)
     零到多个静态方法的定义...(JDK1.8新增)
}

接口的语法规则

• 接口及接口成员默认的访问权限为：public 或 默认
• 常量默认添加static final 关键字
• 抽象方法默认添加 abstract 关键字
• 只有 default 方法及 static 方法可以添加方法体
• 实现接口的类如果不能实现所以接口中待重写的方法，则必须设置为抽象类
• 接口可以实现多继承，即一个子接口可以同时继承多个父接口
• 一个类可以继承自一个父类，同时实现多个接口
• 当一个类同时实现多借口，且其中同时具有相同的方法时，实现类需重写该方法，否则会编译报错

内部类

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类，与之对应，包含内部类的类被称为外部类

分类：

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

成员内部类

内部类中最常见的成员内部类，也称为普通内部类

• 内部类相当于外部类的一个成员变量，可以使用任意访问修饰符
• 内部类中定义的方法可以直接访问外部类中的数据，而不受访问控制符的影响
• 外部类不能直接使用内部类的成员和方法，需要借用内部类对象完成
• 需要通过外部类对象来创建内部类实例
• 如果外部类和内部类具有相同的成员，内部类默认优先访问自己的成员；可以通过“ 外部类.this.对象成员” 以及 “外部类.静态成员” 的方式访问外部类成员
• 编译后产生：外部类$内部类.class

静态内部类

• 静态内部类对象实例时，可以不依赖于外部类对象
• 静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例
• 可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员
• 当内部类属性与外部类属性同名时，默认直接调用内部类中的成员
• 如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式
• 如果需要访问外部类中的非静态属性，则可以通过 new 外部类().属性的方式

方法内部类

• 定义在外部类方法中的内部类，也称局部内部类
• 方法内部类只在其定义所在的方法内部可见，即只在该方法内可使用
• 和方法内部成员使用规则一样，class前面不可以添加public、private、protected、static
• 类中可以包含final、abstract修饰的成员
• 编译后产生：外部类$数字》class

代码实现

Person类

package com.SH.people;

//外部类
public class Person {
	public static int age;

	// 方法内部类
	/*
	* 1、定义在方法内部，作用范围也在方法内
	* 2、和方法内部成员使用规则一样，class前面不可以添加public、private、protected、static
	* 3、类中不能包含静态成员 
	* 4、类中可以包含final、abstract修饰的成员
	*/
	public Object getHeart() {
	
		class Heart {
			public final int age = 13;
			int temp = 22;

			public final void say() {
				System.out.println("hello");
			}

			public void eat() {

			}

			public String beat() {
				new Person().eat();
				return Person.age + "岁的心脏在跳动";
			}
		}
		return new Heart().beat();
		// new Heart().temp=12;
		 temp=33;
		// return new Heart();
	}

	public void eat() {
		System.out.println("人会吃东西");
	}

	// 成员内部类
	/*
	 * 1、内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化 
	 * 2、内部类的访问修饰符，可以任意，但是访问范围会受到影响
	 * 3、内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中定义的 
	 * 4、可以使用外部类.this.成员的方式，访问外部类中同名的信息
	 * 5、外部类访问内部类信息，需要通过内部类实例，无法直接访问 
	 * 6、内部类编译后.class文件命名：外部类$内部类.class
	 * 7、内部类中是否可以包含与外部类相同方法签名的方法？以及如何调用？
	 */
/*
	public class Heart1 {
		int age = 13;
		int temp = 22;

		// public void eat(){....}
		public String beat() {
			eat();
			return Person.this.age + "岁的心脏在跳动";
		}
	}
*/
	// 静态内部类
	/*
	 * 1、静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例 
	 * 2、静态内部类对象实例时，可以不依赖于外部类对象
	 * 3、可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员 
	 * 4、当内部类属性与外部类属性同名时，默认直接调用内部类中的成员；
	 * 如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式； 
	 * 如果需要访问外部类中的非静态属性，则可以通过 new 外部类().属性的方式；
	 */
/*	public static class Heart {
		public static int age = 13;
		int temp = 22;

		public static void say() {
			System.out.println("hello");
		}

		public void eat() {
		}

		public String beat() {
			new Person().eat();
			return Person.age + "岁的心脏在跳动";
		}
	}
*/
}

Test类

package com.SH.test;
import com.SH.people.Person;
//import com.imooc.people.Person.Heart;

public class PeopleTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person lili=new Person();
		lili.age=12;
		
	    /*
		//获取成员内部类对象实例，方式1：new 外部类.new 内部类
		Person.Heart myHeart=new Person().new Heart();
		System.out.println(myHeart.beat());
		
		//获取成员内部类对象实例，方式2：外部类对象.new 内部类
		myHeart=lili.new Heart();
		System.out.println(myHeart.beat());
		
		//获取成员内部类对象实例，方式3：外部类对象.获取方法
		myHeart=lili.getHeart();
		System.out.println(myHeart.beat());
		*/
		
		/*
		//获取静态内部类对象实例
		Person.Heart myHeart=new Person.Heart();
		System.out.println(myHeart.beat());	
		
		Person.Heart.say();
		*/

		System.out.println(lili.getHeart());
	}

}

匿名内部类

• 适用场景：
  -只用到类的一个实例
  -类在定义后马上用到
  -给类命名并不会导致代码更容易被理解
• 使用原则：
  • 不能有构造方法，可以通过构造代码块实现数据初始化
  • 不能定义任何静态成员，静态方法
  • 不能使用private、public、protected、abstract、static修饰
  • 因匿名内部类也是局部内部类，所以局部内部类的所以限制对其都生效
  • 一个匿名内部类一定时在new后面，用其隐含实现一个接口或继承一个类，但是两者不可兼得
  • 只能创建匿名内部类的一个实例
  • 匿名内部类在编译时候由系统自动起名为Outer$1.class
  • 一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或重写
  • 通过匿名内部类返回的时一个对象的引用，所以可以直接使用或将其复制给一个对象变量

代码实现

Person类

package com.SH.anonymous;

public abstract class Person {
	private String name;
	
	public Person(){
		
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public abstract void read();
}

Man类

package com.SH.anonymous;

//public class Man extends Person {
//
//	@Override
//	public void read() {
//		// TODO Auto-generated method stub
//		System.out.println("男生喜欢看科幻类书籍");
//	}
//
//}

Woman类

package com.SH.anonymous;

//public class Woman extends Person {
//
//	@Override
//	public void read() {
//		// TODO Auto-generated method stub
//		System.out.println("女生喜欢读言情小说");
//	}
//
//}

Test类

package com.SH.test;
//import com.SH.anonymous.Man;
import com.SH.anonymous.Person;
//import com.SH.anonymous.Woman;

public class PersonTest {
	//根据传入的不同的人的类型，调用对应的read方法
	//方案1：
//	public void getRead(Man man){
//		man.read();
//	}
//	public void getRead(Woman woman){
//		woman.read();
//	}
	//方案2：
	public void getRead(Person person){
		person.read();
	}
//	
	public static void main(String[] args) {
		PersonTest test=new PersonTest();
//		Man one=new Man();
//		Woman two=new Woman();
//		test.getRead(one);
//		test.getRead(two);
	
		//方案3：匿名内部类
		/*
		 * 1、匿名内部类没有类型名称、实例对象名称
		 * 2、编译后的文件命名：外部类$数字.class
		 * 3、无法使用private、public、protected、abstract、static修饰
		 * 4、无法编写构造方法，可以添加构造代码块
		 * 5、不能出现静态成员
		 */
		test.getRead(new Person(){
			{
				//构造代码块
			}
//			public static int age=12;
			@Override
			public void read() {
				// TODO Auto-generated method stub
				System.out.println("男生喜欢看科幻类书籍");
			}
			
		});
		test.getRead(new Person(){

			@Override
			public void read() {
				// TODO Auto-generated method stub
				System.out.println("女生喜欢读言情小说");
			}
			
		});
	}

}

总结

1. 多态
2. 类型转换
3. 抽象类&抽象方法
4. 接口
5. 内部类