2022年0703 -Com.Java.Basis第十一课《抽象+多态》

2022年0703 第十一课《抽象+多态》第一部分:Java的抽象:Java语言中，用abstract 关键字来修饰一个类时，这个类叫作抽象类。抽象类是它的所有子类的公共属性的集合，是包含一个或多个抽象方法的类。抽象类可以看作是对类的进一步抽象。在面向对象领域，抽象类主要用来进行类型隐藏。特点:

1）抽象类，其修饰符必须为public或者protected，不能是private，因为创建抽象类，就是要被其他类继承，用private修饰了，则不能被子类继承，子类便无法实现该方法。

2）抽象类不能用来创建对象，即抽象类不能被直接实例化，要通过其普通子类进行实例化。

3）如果一个普通子类继承于一个抽象父类，则该类一定要重写实现该父类的抽象方法。如果该子类仍然是一个抽象类，这也是允许的，就不必重写实现该父类的抽象方法，但必须用abstract修饰。

4）抽象级别：抽象类是对整体类的抽象，包含属性和方法。

5）实现类的范围不同：抽象类，其实是从子类中提取共性部分，然后抽象出来，反之，子类继承该父类就可以了，也就是说里面的抽象方法一般来自同一个类别。

6）设计方式不同：抽象类是要先有子类，然后才抽象出父类，是一种从下往上的构建法则。

注意:

1、凡是用abstract修饰符修饰的类被称为抽象类。凡是用abstract修饰符修饰的方法称为抽象方法。

2、抽象类中可以有零个或多个抽象方法，也可以包含非抽象的方法。·抽象类中可以没有抽象方法，但是，有抽象方法的类必须是抽象类。

3、对于抽象方法来说，在抽象类中只指定其方法名及其类型，而不书写其实现代码。

4、抽象类可以派生子类，在抽象类派生的子类中必须实现抽象类中定义的所有抽象方法。

5、抽象类不能创建对象，创建对象的工作由抽象类派生的子类来实现。

6、如果父类中已有同名的abstract方法，则子类中就不能再有同名的抽象方法。

7、abstract不能与final并列修饰同一个类。

8、abstract 不能与private、static、final或native并列修饰同一个方法。

第二部分:Java的多态：

多态性是对象多种表现形式的体现。

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

多态的优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

第三部分:九个案例实操带你深入了解多态:

案例一：

从下面案例可知，A是抽象的，无法直接进行实例化操作。为什么不能直接实例化呢？
当一个类实例化之后，就意味着这个对象可以调用类中的属性或者放过了，但在抽象类里存在抽象方法，
而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。

package com.JavaBasicsDemo6.Abstract;

abstract class A {
    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }

    public abstract void print();
   

    public static class TestDemo {

        public static void main(String[] args) {
//            A a = new A();
        }
    }
}

案例二

现在就可以清楚的发现：
（1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写；
（2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样；
（3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。
虽然一个类的子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外一个普通类，而是去继承抽象类。

package com.JavaBasicsDemo6.Abstract1;

abstract class A{//定义一个抽象类

    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }
    //抽象方法，没有方法体，有abstract关键字做修饰

    public abstract void print();

    public abstract void sleep();

    public abstract void height();

    public abstract void weight();

    public abstract void name();

    public abstract void age();

    public abstract void brither();

    public abstract void X();

    public abstract void XY();





}

package com.JavaBasicsDemo6.Abstract1;

//单继承
public  class B extends A{//B类是抽象类的子类，是一个普通类


    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }

    @Override
    public void sleep() {
        System.out.println("我再睡觉");
    }

    @Override
    public void height() {
        System.out.println("小工的身高178cm");
    }

    @Override
    public void weight() {
        System.out.println("小工的体重89kg");
    }

    @Override
    public void name() {
        System.out.println("小工");
    }

    @Override
    public void age() {
        System.out.println("20岁");
    }

    @Override
    public void brither() {
        System.out.println("2000/10/30");
    }

    @Override
    public void X() {

    }

    @Override
    public void XY() {
        System.out.println("XYXYXY");
    }

}

package com.JavaBasicsDemo6.Abstract1;


public class TestDemo {
    public static void main(String[] args) {
        A a = new B();//向上转型
        a.fun();
        a.print();//被子类所覆写的过的方法
        a.sleep();
        a.brither();
        a.height();
        a.age();
        a.name();
        a.weight();
        a.XY();

    }
}

案例三:

（1）抽象类中有构造方法么？
由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。
并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。

package com.JavaBasicsDemo6.Abstract2;

abstract class A{//定义一个抽象类

    public A(){
        System.out.println("*****A类构造方法*****");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}

package com.JavaBasicsDemo6.Abstract2;


 abstract class B extends A{//B类是抽象类的子类，是一个普通类

    public B(){
        System.out.println("*****B类构造方法*****");
    }

    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }

}

package com.JavaBasicsDemo6.Abstract2;

public class C extends  B {

    @Override
    public void print() {
        System.out.println("我是c方法");
    }

    public    C(){
        System.out.println("我是c构造的方法");
    }
}

package com.JavaBasicsDemo6.Abstract2;

public class TestDemo {
    public static void main(String[] args) {
        A a = new C();//向上转型
        a.print();
    }

}

案例四:

（2）抽象类可以用final声明么？
不能，因为抽象类必须有子类，而final定义的类不能有子类
（3）抽象类能否使用static声明？
先看一个关于外部抽象类的范例：

package com.JavaBasicsDemo6.Abstract3;

  static  abstract class A{//定义一个抽象类

    public abstract void print();

}

package com.JavaBasicsDemo6.Abstract3;

class B extends A{

    public void print(){
        System.out.println("**********");
    }
}

package com.JavaBasicsDemo6.Abstract3;




public class TestDemo {
    public static void main(String[] args) {
        A a = new B();//向上转型
        a.print();
    }
}

案例五:

 由此可见，外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。
 使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。

package com.JavaBasicsDemo6.Abstract4;

abstract class A{//定义一个抽象类

    static abstract class B{//static定义的内部类属于外部类
        public abstract void print();
    }

}

class C extends A.B{

    public void print(){
        System.out.println("**********");
    }
}
class TestDemo {

    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.print();
    }

}

案例六：

可以直接调用抽象类中用static声明的方法么？
任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。
范例如下：

package com.JavaBasicsDemo6.Abstract5;


abstract class A{//定义一个抽象类

    public static void print(){
        System.out.println("Hello World !");
    }

}

class TestDemo {

    public static void main(String[] args) {
        A.print();
    }
}

案例七:

有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。
这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。

package com.JavaBasicsDemo6.Abstract6;


abstract class A{//定义一个抽象类
    public abstract void print();

    private static class B extends A{//内部抽象类子类

        public void print(){//覆写抽象类的方法
            System.out.println("Hello World !");
        }
    }

    //这个方法不受实例化对象的控制
    public static A getInstance(){
        return new B();
    }

}

class TestDemo {

    public static void main(String[] args) {

        //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
        A a = A.getInstance();
        a.print();
    }
}

案例八:综合案例一

package com.JavaBasicsDemo6.Abstract7;


public class Circle extends Shape {
    public double r = 10;

    public Circle() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Circle(String shapName, double r) {
        super(shapName);
        this.r = r;
    }

    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        System.out.println("圆的面积为：" + Math.PI * r * r);
        return Math.PI * r * r;
    }
}


package com.JavaBasicsDemo6.Abstract7;

public class Rectangle extends Shape{
    public double width=10;
    public double height=10;

    public Rectangle() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Rectangle(String shapName, double width, double height) {
        super(shapName);
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        System.out.println("长方形的面积为："+width*height);
        return width*height;
    }

}

package com.JavaBasicsDemo6.Abstract7;


public abstract class Shape {
    public String shapName;

    public Shape() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Shape(String shapName) {
        super();
        this.shapName = shapName;
    }

    public String getShapName() {
        return shapName;
    }

    public void setShapName(String shapName) {
        this.shapName = shapName;
    }
    
    public abstract double getArea();
}


package com.JavaBasicsDemo6.Abstract7;

public abstract class Triangle extends Shape{
    public double border;
    public double height;
    public Triangle(){
        super();
        // TODO Auto-generated constructor stub
    }
    public Triangle(String shapName, double border, double height) {
        super(shapName);
        this.border = border;
        this.height = height;
    }

}


package com.JavaBasicsDemo6.Abstract7;
public class ShapeTest {

    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Shape s = new Circle();
        s.getArea();
        s.getShapName();


        Shape r = new Rectangle();
        r.getArea();
        r.getShapName();



    }

}

案例九:综合案例二:

package com.JavaBasicsDemo6.Abstract8;

public class Animal {
    public int age = 40;
    public String name;

    public Animal() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Animal(String name) {
        super();
        this.name = name;
    }

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



package com.JavaBasicsDemo6.Abstract8;

public class Cat extends Animal{
    public int age = 15;
    public int weight = 10;
    public Cat() {

    }
    public Cat(String name) {
        super(name);
    }
    @Override
    public void eat(){
        // TODO Auto-generated method stub
        System.out.println("猫抓老鼠");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

package com.JavaBasicsDemo6.Abstract8;


public class Dog extends Animal{
    public void guard(){

    }
}



package com.JavaBasicsDemo6.Abstract8;

public class AnimalTest {

    public static void main(String[] args) {
        // 创建一个Animal对象
        Animal a = new Animal();

        //创建一只猫
        Cat c = new Cat("猫");
        thinking(c);
        //父类型的引用接收了（指向）子类型的对象，称为向上造型
        Animal a1 = new Dog();
        System.out.println(a1.age);
        a1.eat();

//		Cat c1 = (Cat)new Animal();

    }

    public static void thinking(Animal animal) {//各种动物在思考Animal animal = new Cat();
        if (animal.name == "猫") {
            System.out.println("猫在思考");
        }
        if (animal.name == "狗狗") {
            System.out.println("狗在思考");
        }
    }

}

案例十:综合案例三：

package abstact;

public abstract class Student {
	//姓名
		private String name;
		//年龄
		private int age;
		//班级
		private String grand;
		
		public Student(){}
		
		public Student(String name,int age,String grand){
			this.name = name;
			this.age = age;
			this.grand = grand;
		}
		
		//getXxx()/setXxx()
		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 String getGrand(){
			return grand;
		}
		
		public void setGrand(String grand){
			this.grand = grand;
		}
		
		//学习study(抽象方法) (抽象方法)
		public abstract void study();
		
		
		//学习打王者游戏(抽象方法 playingking)
		public abstract void playingking();
		
		//学习english (抽象方法)
		public abstract void learnenglish();
		
		//吃饭eat(具体方法)
		public void eat(){
			System.out.println("学习累了,去吃饭");
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + age;
			result = prime * result + ((grand == null) ? 0 : grand.hashCode());
			result = prime * result + ((name == null) ? 0 : name.hashCode());
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Student other = (Student) obj;
			if (age != other.age)
				return false;
			if (grand == null) {
				if (other.grand != null)
					return false;
			} else if (!grand.equals(other.grand))
				return false;
			if (name == null) {
				if (other.name != null)
					return false;
			} else if (!name.equals(other.name))
				return false;
			return true;
			
		}

		@Override
		public String toString() {
			return "Student [name=" + name + ", age=" + age + ", grand=" + grand + "]";
		}
		
	}

	





package abstact;

//定义具体基础班学员类
public class BasicStudent  extends Student{
	
	public BasicStudent(){
		super();
	}
	
	public void study(){
		System.out.println("基础班学员学习的是JavaSE");
	}

	public void playingking() {
		System.out.println("学会一点游戏，不是很好");
		
	}

	public void learnenglish() {
		System.out.println("英语学的是皮毛");
		
	}

	}
	
	


package abstact;

public class OutstandingStudent  extends Student{
	

	public OutstandingStudent() {}

	public OutstandingStudent(String name, int age, String grand) {
		super(name, age, grand);
		
	}

	@Override
	public void study() {
		System.out.println("好好学习，天天向上");
	}

	@Override
	public void playingking() {
		System.out.println("王者是什么呢");
		
	}

	@Override
	public void learnenglish() {
		System.out.println("english很厉害");
		
	}

}


package abstact;

//定义具体就业班学员类
public class WorkStudent extends Student{
	public WorkStudent(){}
	
	public WorkStudent(String name,int age,String grand){
		super(name,age,grand);
	}
	
	public void study(){
		System.out.println("就业班学员学习的是JavaEE");
	}

	@Override
	public void playingking() {
		System.out.println("游戏上王者，学业一事无成");
		
	}

	@Override
	public void learnenglish() {
		System.out.println("I don't like english");
		
	}
	
}



package abstact;

public class StudentTest {

	public static void main(String[] args) {
			//基础班学员测试
			//多态(测试)
			//方式1
		Student s1 = new BasicStudent();
			s1.setName("一日王月");
			s1.setGrand("bdqn_S1");
			System.out.println(s1.getName()+"---"+s1.getAge()+"---"+s1.getGrand());
			s1.study();
			s1.eat();
			s1.learnenglish();
			s1.playingking();
			System.out.println("---------------------------------");
			//方式2
			s1 = new BasicStudent();
			System.out.println(s1.getName()+"---"+s1.getAge()+"---"+s1.getGrand());
			s1.study();
			s1.eat();
			s1.learnenglish();
			s1.playingking();
			System.out.println("---------------------------------");
			//就业班学员测试
			//方式1
			Student 	s = new WorkStudent();
			s.setName("我的人生");
			s.setAge(25);
			s.setGrand("bdqn_Y2");
			System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
			s.study();
			s.eat();
			s.learnenglish();
			s.playingking();
			System.out.println("---------------------------------");
			//方式2
			s = new BasicStudent();
			System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
			s.study();
			s.eat();
			System.out.println(s.hashCode());
			System.out.println("---------------------------------");	
			//优秀学员
			//方式1
			Student a	 =new  OutstandingStudent();
			a.setName("自学成才");
			a.setAge(20);
			a.setGrand("bdqn_S1——阿0298");
			System.out.println(a.getName()+"---"+a.getAge()+"---"+a.getGrand());
			a.study();
			a.eat();
			a.learnenglish();
			a.playingking();
			System.out.println(a.hashCode());
			System.out.println("---------------------------------");
			
			//方式2
			a = new BasicStudent();
			System.out.println(a.getName()+"---"+a.getAge()+"---"+a.getGrand());
			a.study();
			a.eat();
			a.learnenglish();
			a.playingking();
			System.out.println(s.hashCode());
			System.out.println("---------------------------------");
			
			
			
	
			
	}
}

2022年0703 -Com.Java.Basis第十一课 《抽象+多态》

Java相关栏目本月热门文章

2022年0703 -Com.Java.Basis第十一课《抽象+多态》