Day13(java面向对象)学习笔记（接口、匿名对象&final、多态）

大纲

通过今天的学习，参训学员能够：（解释的时候说出二级目标的掌握程度）

1. 【应用】接口

1. 【应用】能够独立定义接口和实现类
2. 【理解】能够阐述接口中成员的特点
3. 【理解】能够独立阐述接口的优点
4. 【理解】能够独立阐述接口和抽象类的区别
5. 【应用】能够独立写出运动员案例

1. 【理解】匿名对象&final

1. 【应用】能够独立创建匿名对象并使用
2. 【理解】能够阐述final修饰类,变量和方法的特点

1. 【理解】多态

1. 【理解】能够阐述什么是多态
2. 【应用】能够独立定义多态
3. 【理解】能够阐述多态中成员的特点
4. 【应用】能够独立完成多态向上转型和向下转型的案例
5. 【理解】能够独立阐述多态的优缺点

收获：

一接口

类与接口的关系为实现关系，即类实现接口

一个类只能有一个父类，打破了继承的局限性；一个类可以实现多个接口

package com.itheima_02;

public class InterfaceTest {
	public static void main(String[] args) {
		//创建篮球运动员对象
		BasketBallPlayer bbp = new BasketBallPlayer();
		bbp.name = "女兆月日";
		bbp.age = 35;
		bbp.gender = "男";
		bbp.sleep();
		bbp.study();
		bbp.speak();
		System.out.println("-------------");
		//创建乒乓球教练对象
		PingpangCoach ppc = new PingpangCoach();
		ppc.name = "刘胖子";
		ppc.age = 40;
		ppc.gender = "男";
		ppc.sleep();
		ppc.teach();
		//ppc.speak();
		
		
		
	}
}

class Person {
	String name;//姓名
	int age;//年龄
	String gender;//性别
	
	//无参构造
	public Person() {}
	
	//有参构造
	public Person(String name,int age,String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	//吃
	public void eat() {
		System.out.println("吃饭");
	}
	
	//睡
	public void sleep() {
		System.out.println("睡觉");
	}
}

//学习说英语
interface SpeakEnglish {
	public abstract void speak();
}

//运动员
abstract class Player extends Person {
	//学习
	public abstract void study();
}

//教练
abstract class Coach  extends Person {
	//教
	public abstract void teach();
}

//篮球运动员
class BasketBallPlayer extends Player  implements SpeakEnglish{

	@Override
	public void study() {
		System.out.println("学扣篮");
	}

	@Override
	public void speak() {
		System.out.println("说英语");
	}
	
}
//乒乓球运动员
class PingpangPlayer extends Player {

	@Override
	public void study() {
		System.out.println("学抽球");
	}
	
}
//篮球教练
class BasketBallCoach extends Coach implements SpeakEnglish {

	@Override
	public void teach() {
		System.out.println("教扣篮");
	}

	@Override
	public void speak() {
		System.out.println("说英语");
	}
	
}
//乒乓球教练
class PingpangCoach extends Coach {

	@Override
	public void teach() {
		System.out.println("教抽球");
	}
	
}

二匿名对象

 package com.itheima_01;
/*
 * 匿名对象:没有名字的对象
 * 匿名对象的应用场景：
 * 		当方法只调用一次的时候可以使用匿名对象
 * 		可以当作参数进行传递，但是无法在传参之前做其他的事情
 * 	
 * 注意：匿名对象可以调用成员变量并赋值，但是赋值并没有意义
 * 			
 */
public class AnonymousObejctDemo {
	public static void main(String[] args) {
		//Student s = new Student();
		//s.study();
		//s.study();
		//s.study();
		
		//new Student();//匿名对象，没有变量引用的对象
		//new Student().study();
		//new Student().study();
		//new Student().study();
		
		//new Student().age = 18;
		//System.out.println(new Student().age);
		
		
		//Student s = new Student();
		//s.age = 18;
		//s.name = "张三";
		//method(s);
		
		method(new Student());
		
	}
	
	public static void method(Student s) {
		
	}

		
}

三 final 关键字

   package com.itheima_01;
/*
 * final： 修饰符，可以用于修饰类、成员方法和成员变量
 * final所修饰的类：不能被继承，不能有子类
 * final所修饰的方法:不能被重写
 * final所修饰的变量：是不可以修改的，是常量
 * 
 * 常量：
 * 		字面值常量：1,2,3
 * 		自定义常量：被final所修饰的成员变量，一旦初始化则不可改变
 * 
 * 注意：自定义常量必须初始化，可以选择显示初始化或者构造初始化
 * 
 *  
 */
public class FinalDemo {
	public static void main(String[] args) {
		//Animal a = new Animal();
		//a.eat();
		
		Dog d = new Dog();
		//d.eat();
		
		//d.num = 20;
		System.out.println(d.NUM);
	}
}

/*final*/ class Animal {
	public final void eat() {
		System.out.println("吃东西");
	}
}

class Dog extends Animal {
	/*public void eat() {}*/
	
	final int NUM;
	
	public Dog() {
		NUM = 10;
	}
}

四 多态

多态是继封装、继承之后，面向对象的第三大特性。

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

package com.itheima_01;

public class PoymorphicDemo2 {
	public static void main(String[] args) {
		Dad d = new Kid();
		//System.out.println(d.num);
		
		//d.method();//调用子类
		d.function();//有static,则调用父类
	}
}

class Dad {
	int num = 20;
	
	public void method() {
		System.out.println("我是父类方法");
	}
	
	public static void function() {
		System.out.println("我是父类静态方法");
	}
}

class Kid extends Dad {
	int num = 10;
	
	public void method() {
		System.out.println("我是子类方法");
	}
	
	public static void function() {
		System.out.println("我是子类静态方法");
	}
}

  package com.itheima_02;
/*
 *	
 * 	多态中的向上转型和向下转型:
 * 
 *  引用类型之间的转换
 *  	向上转型
 *  		由小到大(子类型转换成父类型)
 *  	向下转型
 *  		由大到小
 *  基本数据类型的转换
 *  	自动类型转换
 *  		由小到大
 *  		byte short char --- int --- long --- float --- double
 *  	强制类型转换
 *  		由大到小
 *  		
 * 	
 * 
 */
public class PoymorphicDemo3 {
	public static void main(String[] args) {
		Animal2 a = new Dog();//向上转型，要父类与子类都定义了的
		a.eat();
		
		
		Dog d = (Dog)a;//向下转型，子类定义了即可
		d.swim();
		
		
	}
}

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


class Dog extends Animal2 {
	public void eat() {
		System.out.println("啃骨头");
	}
	
	public void swim() {
		System.out.println("狗刨");
	}
}

五 多态优缺点

 package com.itheima_01;
/*
 *	
 * 	多态的优缺点
 * 		优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性
		缺点：无法直接访问子类特有的成员
 */
public class PoymorphicDemo4 {
	public static void main(String[] args) {
		MiFactory factory = new MiFactory();
		factory.createPhone(new MiNote());
		
		factory.createPhone(new RedMi());
	}

	
}

class MiFactory {
	/*public void createPhone(MiNote mi) {
		mi.call();
	}
	
	public void createPhone(RedMi mi) {
		mi.call();
	}*/
	
	public void createPhone(Phone p) {
		p.call();
	}
	
}

interface Phone {
	public void call();
}

//小米Note
class MiNote implements Phone{
	public void call() {
		System.out.println("小米Note打电话");
	}
}

//红米
class RedMi implements Phone {
	public void call() {
		System.out.println("红米打电话");
	}
}