米鼠商城

多快好省,买软件就上米鼠网

最新项目

人才服务

靠谱的IT人才垂直招聘平台

day12 面向对象(下)

  • xx
  • 8
  • 2020-07-30 09:03

精选30+云产品,助力企业轻松上云!>>>

day12 面向对象(下) PQ

一、三大特性之多态(polymorphism)

1、多态的简介

(1)概念

​ 单态:这个对象只有唯一的一种状态

​ Student s = new Student();

​ 多态:这个对象存在多种状态。 是指同一行为,具有多个不同表现形式。

(2)多态实现的前提

​ 1)要有继承或者实现的关系

​ 2)方法的重写(如果没有方法重写,格式不会报错,这样的多态是没有任何意义)

​ 3)父类的引用指向子类对象(父new子)或者父接口的引用指向实现类对象(父接口new实现类)

2、多态的体现

(1)多态体现的格式

父类类型 变量名 = new 子类对象();
变量名.方法名();

eg:
Animal dog = new Dog();
dog.eat();

(2)多态思想下成员的特点

1)实例变量

​ 对象被什么数据类型所修饰,这个变量就会调用谁的实例变量

//父类:SuperClass
public class SuperClass {
	int num = 10;
}
//子类:SubClass
public class SubClass extends SuperClass {
	int num = 20;
}
//测试类:PolyDemo02
public class PolyDemo02 {
	public static void main(String[] args) {
		//父new父
		SuperClass superC = new SuperClass();
		System.out.println(superC.num);//10
		//子new子
		SubClass subC = new SubClass();
		System.out.println(subC.num);//20
		System.out.println("===================");
		//利用多态创建对象
		SuperClass sc = new SubClass();
		System.out.println(sc);//com.atguigu.poly.demo02.SubClass@15db9742 子类地址值
		System.out.println(sc.num);//10
	}
}
2)实例方法

​ 先看父类中是否有这个方法,如果有,执行子类重写后的方法;如果没有,编译报错

//父类:SuperClass
public class SuperClass {
	public void method () {
		System.out.println("父类的实例方法");
	}
}
//子类:SubClass
public class SubClass extends SuperClass {
	public void method () {
		System.out.println("子类重写后的实例方法");
	}
}
//测试类:PolyDemo04
public class PolyDemo04 {
	public static void main(String[] args) {
		//父new父
		SuperClass superC = new SuperClass();
		System.out.println(superC);  //com.atguigu.poly.demo04.SuperClass@15db9742
		superC.method();//父类的实例方法
		System.out.println("==============");
		//子new子
		SubClass subC = new SubClass();
		System.out.println(subC);//com.atguigu.poly.demo04.SubClass@6d06d69c
		subC.method();//父类的实例方法
		System.out.println("==============");
		//父new子
		SuperClass sc = new SubClass();
		System.out.println(sc);//com.atguigu.poly.demo04.SubClass@7852e922
		sc.method();//父类的实例方法
	}
}
3)构造器

​ 和原来一样

//父类:SuperClass
public class SuperClass {
	
	public SuperClass () {
		System.out.println("父类的构造器");
	}
}
//子类:SubClass
public class SubClass extends SuperClass {
	
	public SubClass(){
		//super(); 此处隐藏了JVM提供的super()
		System.out.println("子类的构造器");
	}
}
//测试类PolyDemo03
public class PolyDemo03 {
	public static void main(String[] args) {
		//父new父
		SuperClass superC = new SuperClass();//父类的构造器
		System.out.println("================");
		//子new子
		SubClass subC = new SubClass();//父类的构造器      子类的构造器
		System.out.println("================");
		// 父new子
		SuperClass sc = new SubClass();//父类的构造器      子类的构造器
		System.out.println(sc);	//com.atguigu.poly.demo03.SubClass@15db9742	
	}
}

3、多态的好处和弊端

(1)多态的好处

  • 声明方法时,不再将形参写具体的引用数据类型,直接写父类的类型或者父类接口的类型
  • 对象数组的应用
//Student类
public class Student {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
    //设置满参构造器
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	//重写系统中自带的toString方法
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	
}
//测试类:PolyDemo05
public class PolyDemo05 {
	public static void main(String[] args) {
		Student s1 = new Student("张三",18);
		Student s2 = new Student("李四",23);
		Student s3 = new Student("钱五",43);
		Student s4 = new Student("孙六",23);
		//对象数组
		Student[] arr = {s1,s2,s3,s4};
		
		printArr(arr);
	}
	//object为顶级父类,将其放置形参
	private static void printArr(Object[] arr) { 
		for (int i = 0; i < arr.length; i++) {
			Object obj = arr[i];
			System.out.println(obj);
		}
	}
}
//运行结果
Student [name=张三, age=18]
Student [name=李四, age=23]
Student [name=钱五, age=43]
Student [name=孙六, age=23]

(2)多态的弊端及解决办法

1)多态的弊端

​ 在多态的情况下,对象无法调用自己的特有方法,只能调用子类改写父类的方法。

2)多态的解决方法

​ 解决多态的弊端,引用数据类型的类型转换

类型转换名称 类型转换方向
向上转型(默认转换方式) 将子类的对象或者实现类的对象转换为父类的类型或者父接口类型(多态)
向下转型(强制类型转换) 将父类类型或者父接口类型转换为子类类型或者实现类类型
  • 向下转型(强制类型转换)格式:
子类类型   对象名 = (子类类型)父类类型的对象;
eg:
Animal cat = new Cat();  //多态
Dog dog = (Dog)cat;      //强转
  • 引用数据类型强制类型转换时注意事项:

    可能会发生ClassCastException:类型转换异常

3)instanceof关键字的引入

​ 强制转换时易发生类型转换异常,使用instanceof给引用变量做类型的校验

  • instanceof使用格式
变量名 instanceof 数据类型 

eg:
c instanceof Cat
  • instanceof返回值

    instanceof为关系运算符,如果变量属于该数据类型,返回true;如果变量不属于该数据类型,返回false。

4、练习题:猫狗

1.定义动物类
		属性:年龄,颜色
		行为:eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,
			something表示吃的东西)生成空参有参构造,set和get方法
	2.定义狗类继承动物类	  
		行为:eat(String something)方法,看家lookHome方法(无参数)
	3.定义猫类继承动物类
		行为:eat(String something)方法,逮老鼠catchMouse方法(无参数)
	4.定义Person类
		属性:姓名,年龄
		行为:keepPet(Dog dog,String something)方法
		功能:喂养宠物狗,something表示喂养的东西
		行为:keepPet(Cat cat,String something)方法
		功能:喂养宠物猫,something表示喂养的东西
		实现以上两种行为,思考如何只写一个方法?
		生成空参有参构造,set和get方法  	
	5.测试以上方法
	  使用多态、强转、instanceof等
//Animal类
public abstract class Animal {
	private int age;
	private String color;
    //设置set()、get()方法
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	//设置无参构造器和满参构造器
	public Animal(int age, String color) {
		super();
		this.age = age;
		this.color = color;
	}
	public Animal() {
		super();
	}
	//设置动物类的抽象方法
	public abstract void eat(String something);
}
//Cat类 继承 Animal类
public class Cat extends Animal{
	//重写父类eat方法
	public void eat(String something) {
		System.out.println(getAge() + "岁" + getColor() + "色的小猫正在吃" + something);
	}
	//逮老鼠方法
	public void catchMouse () {
		System.out.println(getAge() + "岁" + getColor() + "色的小猫正在逮老鼠");
	}
	//设置构造器
	public Cat() {
		super();
	}

	public Cat(int age, String color) {
		super(age, color);
	}
}
//Dog类 继承 Animal类
public class Dog extends Animal{
	//重写父类抽象方法
	@Override
	public void eat(String something) {
		System.out.println(getAge() + "岁" + getColor() + "色的小狗正在吃" + something);
	}
	
	public void lookHome(){
		System.out.println(getAge() + "岁" + getColor() + "色的小狗正在看家");
	}
	//设置构造器
	public Dog() {
		super();
	}

	public Dog(int age, String color) {
		super(age, color);
	}	
}
//Person类
public class Person {
	//喂养狗和喂养猫的方法为方法的重载,可以直接使用多态的好处一:声明方法时,不再将形参写具体的引用数据类型,直接写父类的类型或者父类接口的类型
	/*// 喂养狗的方法
	public void keepPet(Dog dog,String something) {
		dog.eat(something);
	}
	
	// 喂养猫的方法
	public void keepPet(Cat cat,String something) {
		cat.eat(something);
	}*/
	
	public void keepPet (Animal a,String something) {
		a.eat(something);
	}
}
//测试类:
public class PolyDemo06 {
	public static void main(String[] args) {
		//创建猫对象
		Animal cat = new Cat(2,"白");
		//创建狗的对象
		Animal dog = new Dog(3,"黑");
		//创建人对象
		Person p = new Person();
		// 调用饲养员的喂养猫的方法
		p.keepPet(cat, "鱼");
		
		// 将多态形式的对象进行向下转型
		if (cat instanceof Cat) {
			Cat c = (Cat)cat;
			c.catchMouse();
		}
		//cat对象不属于Dog,判断返回false
		if (cat instanceof Dog) {
			Dog d = (Dog)cat;
			d.lookHome();
		}
		//Cat c = (Cat)dog;	
		//c.catchMouse();
		System.out.println("==================");
		// 调用饲养员喂养狗的方法
		p.keepPet(dog, "骨头");
	}
}

二、匿名内部类



这里给大家推荐一个在线软件复杂项交易平台:米鼠网 https://www.misuland.com

米鼠网自成立以来一直专注于从事软件项目人才招聘软件商城等,始终秉承“专业的服务,易用的产品”的经营理念,以“提供高品质的服务、满足客户的需求、携手共创双赢”为企业目标,为中国境内企业提供国际化、专业化、个性化、的软件项目解决方案,我司拥有一流的项目经理团队,具备过硬的软件项目设计和实施能力,为全国不同行业客户提供优质的产品和服务,得到了客户的广泛赞誉。



如有侵权请联系邮箱(service@misuland.com)

猜你喜欢

评论留言