java基础---多态、抽象类、object、解析以及小结
1 Object(掌握)
Object类是所有类型的父类
一个类如果没有父类，JVM在运行的时候会为这个类默认指定一个父类（Object）
注意：Java只能支持单继承，也就是说一个子类最多只能继承一个父类
public class Person extends Object{
}
Object成员方法如下：
场景：我定义一个类Student，这个类默认会继承Object，此时我让Student去覆写Object的toString()方法，目的将Student转换为String类型
package com.sxt.day02.demo02;
import java.util.Objects;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 10:13
* @Version 1.0
**/
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;
}
/**
* 将学生的属性信息转换成字符串，此时覆写了Object类型的toString()方法
* @return 学生的字符串信息
*/
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类：
package com.sxt.day02.demo02;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 10:17
* @Version 1.0
**/
public class TestStudent {
public static void main(String[] args) {
Student tom = new Student();
tom.setAge(18);
tom.setName("Tom");
// tomInfo 存储量tom对象的信息
/**
* 实体类一定要覆写Object类型的toString方法，该方法能够像外界提供对象的信息，所以也叫作名片方法
* */
/**
* 程序执行的时候jvm会检查tom对象有没有定义toString()方法，如果定义了就调用，如果没定义
* 就调用父类型的toString()方法，此时Student的父类型是Object
*/
String tomInfo = tom.toString();
System.out.println(tomInfo);
}
}
场景：我定义一个类Student，此时我让Student去覆写Object的equals()和hashCode()方法
package com.sxt.day02.demo02;
import java.util.Objects;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 10:13
* @Version 1.0
**/
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;
}
/**
* 将学生的属性信息转换成字符串
* @return
*/
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
// 参数的地址跟当前对象的地址一样就返回true
// this此时表示tom1 ， o此时表示tom2
if (this == o) return true;
// 参数为空或者类新信息不一致，返回false
if (o == null || getClass() != o.getClass()) return false;
// 此时逐个比较tom1和tom2的每个属性值，如果属性值全部相等返回true，否则返回false
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
测试类：
package com.sxt.day02.demo02;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 10:27
* @Version 1.0
**/
public class TestEquals {
/**
* 创建两个对象，调用equals判断真假
* @param args
*/
public static void main(String[] args) {
Student tom1 = new Student();
Student tom2 = new Student();
tom1.setName("Tom");
tom1.setAge(18);
tom2.setName("Tom");
tom2.setAge(18);
// 没有覆写Object类型的equals()方法的情况下结果：false
// 如何由false变为true？此时Student需要覆写Object类型的equals()和hashCode()
System.out.println(tom1.equals(tom2));
}
}
注意：工作中定义实体类(例如：Farmer、Student)，必须覆写Object类型的toString()、hashCode()、equals()方法。
2 对象之间的关联(理解)
如果说继承是父子之间的垂直关系（父在上，子在下），那么关联就是水平关系(例如：学生有车)
继承：is a
关联：has a
共性：都能够做到代码的复用
场景：学生有车
package com.sxt.day02.demo03;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:03
* @Version 1.0
**/
public class Car {
private String bread;
private String color;
public String getBread() {
return bread;
}
public void setBread(String bread) {
this.bread = bread;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Car(String bread, String color) {
this.bread = bread;
this.color = color;
}
/**
* 车有启动的行为
*/
public void start(){
System.out.println(bread+"启动了，颜色"+color);
}
public void speed(){
System.out.println(bread+"加速");
}
public void stop(){
System.out.println(bread+"停止");
}
@Override
public String toString() {
return "Car{" +
"bread='" + bread + '\'' +
", color='" + color + '\'' +
'}';
}
}
package com.sxt.day02.demo03;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:08
* @Version 1.0
**/
public class Student {
/**
* 学生有姓名
*/
private String stuName;
/**
* 学生有车
*/
private Car bmw = new Car("宝马","blue");
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public Car getBmw() {
return bmw;
}
public void setBmw(Car bmw) {
this.bmw = bmw;
}
public Student() {
}
public Student(String stuName, Car bmw) {
this.stuName = stuName;
this.bmw = bmw;
}
public Student(String stuName) {
this.stuName = stuName;
}
/**
* 学生具备学习方法,先开车到学校，然后开始学习
*/
public void study(){
bmw.start();
System.out.println(stuName+"开着车来学校学习");
}
}
package com.sxt.day02.demo03;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:13
* @Version 1.0
**/
public class TestStudent {
public static void main(String[] args) {
/**
* 1 创建学生对象
* 2 调用study方法，让学生开着车来学习
*/
Student tom = new Student("Tom");
tom.study();
}
}
关联的好处：代码复用，此时多个学生对象都可以使用Car的行为
3 深入向上转型（重点）
package com.sxt.day02.demo04;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:32
* @Version 1.0
* 所有形状的父类，每个形状都有绘画的方法
**/
public class Shape {
public void draw(){
System.out.println("形状Shape开始绘画");
}
}
package com.sxt.day02.demo04;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:32
* @Version 1.0
* 圆形是形状的子类：子类覆盖了父类的方法
**/
public class Circle extends Shape {
public void draw() {
System.out.println("圆形Circle开始绘画");
}
}
package com.sxt.day02.demo04;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:33
* @Version 1.0
矩形是形状的子类：子类覆盖了父类的方法
**/
public class Rectangle extends Shape {
public void draw(){
System.out.println("矩形Rectangle开始绘画");
}
}
package com.sxt.day02.demo04;
/**
* @Description 三角形是形状的子类：子类覆盖了父类的方法
* @Author caojie
* @Date 2020/7/22 11:34
* @Version 1.0
**/
public class Triangle extends Shape{
public void draw(){
System.out.println("三角形 开始绘画");
}
}
package com.sxt.day02.demo04;
import com.sun.scenario.animation.shared.TimerReceiver;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:35
* @Version 1.0
* 在纸上面画形状
**/
public class Paper {
/**
* 在纸上面操作圆形(画圆形)
* @param circle
*/
public static void operatorCircle(Circle circle){
circle.draw();
}
/**
* 在纸上面画三角形
* @param triangle
*/
public static void operatorTirangle(Triangle triangle){
triangle.draw();
}
/**
* 在纸上面画矩形
* @param rectangle
*/
public static void operatorRectangle(Rectangle rectangle){
rectangle.draw();
}
/**
* 创建三个子类对象，然后调用operator相关的方法进行绘画
* @param args
*/
public static void main(String[] args) {
Circle cc = new Circle();
Triangle tt = new Triangle();
Rectangle rr = new Rectangle();
// 调用静态方法进行绘画操作
operatorCircle(cc);
operatorRectangle(rr);
operatorTirangle(tt);
}
}
上面的示例有缺陷，每增加一个子类，我都要修改Perper类，都要添加具体的operatortXXX方法，代码无法复用
优化上一个示例，只定义一个operator(Shape sh)方法，将父类作为形参，程序运行的时子类作为实参传入到父类中。
package com.sxt.day02.demo04;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:35
* @Version 1.0
* 在纸上面画形状
*
**/
public class Paper2 {
/**
* 在纸上操作(画)形状
* Paper只关注形状，不用关注具体的子类
* 此时使用父类作为形参
* @param sh
*/
public static void operator(Shape sh){
sh.draw();
}
/**
* 创建三个子类对象，然后调用operator相关的方法进行绘画
* @param args
*/
public static void main(String[] args) {
Circle cc = new Circle();
Triangle tt = new Triangle();
Rectangle rr = new Rectangle();
// 调用静态方法进行绘画操作
//操作圆形
operator(cc);
//操作 三角形
operator(tt);
// 操作矩形
operator(rr);
}
}
参数向上转型小结：父类作为形参，子类作为实参,程序运行期实参传入到形参中
// sh此时有两种状态，编译期sh指向父类型Shape，运行期sh指向子类型
public static void operator(Shape sh)
4 多态（重点）
概念1：编译期不知道子类对象的类型，而是在运行期创建对象，调用恰当的方法
概念2：父类定义共性的行为，例如：Shape作为父类定义draw(), 如何绘画让子类去实现，同一个方法，可以由每个子类进行不同的实现(圆形、三角形、矩形它们的绘画方式不一样，但是他们都具备绘画的行为)
多态的支撑点：方法覆写和向上转型
目的：父类定义共性行为(做什么)，通常父类不去做事，如何做全部下沉到子类。
做什么(父类定义的void draw()方法)和怎么做(子类来覆盖父类的void draw())分离
场景：形状体系，一个父类，三个子类。输入1画圆形，输入2画三角形，输入3画矩形
特点：编译期不知道创建那个子类，只有在运行期根据客户输入的数字才能创建具体的对象
package com.sxt.day02.demo05;
/**
* @Description 所有形状类型的父类
* @Author caojie
* @Date 2020/7/22 14:21
* @Version 1.0
**/
public class Shape {
/**
* 父类定义做什么
* 此时方法体为空，也是一个哑巴方法
* 怎么做下沉到子类
*/
public void draw(){}
}
package com.sxt.day02.demo05;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:32
* @Version 1.0
* 圆形是形状的子类：子类覆盖了父类的方法
**/
public class Circle extends Shape {
public void draw() {
System.out.println("形状Circle开始绘画");
}
}
package com.sxt.day02.demo05;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:33
* @Version 1.0
**/
public class Rectangle extends Shape {
public void draw(){
System.out.println("形状矩形Rectangle开始绘画");
}
}
package com.sxt.day02.demo05;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 11:34
* @Version 1.0
**/
public class Triangle extends Shape {
public void draw(){
System.out.println("三角形 开始绘画");
}
}
package com.sxt.day02.demo05;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 14:23
* @Version 1.0
* 形状工厂，唯一职责就是创建形状相关的产品
**/
public class ShapeFactory {
/**
* 根据客户输入的参数来决定创建的产品
* 输入1画圆形，输入2画三角形，输入3画矩形
* 注意：sh 此时有两种状态，编译期sh是Shape类型，运行期一旦该方法被调用sh就是子类型
* @param index
* @return 形状
*/
public static Shape create(int index){
Shape sh = null;
switch (index) {
case 1:
sh = new Circle();
break;
case 2:
sh = new Triangle();
break;
case 3:
sh = new Rectangle();
break;
}
return sh;
}
}
package com.sxt.day02.demo05;
import java.util.Scanner;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 14:26
* @Version 1.0
* 在纸上绘画形状
* 1 定义Scanner
* 2 接收用户的输入
* 3 根据用户输入的数字使用工厂的静态方法来创建具体的对象
* 4 调用对象的draw()方法进行绘画
* 多态好处：外界只用关注父类(Shape),可以完全忽略子类的存在
**/
public class Paper {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入数字：输入1画圆形，输入2画三角形，输入3画矩形");
int num = input.nextInt();
// check
if(num<1 || num>3){
System.err.println("输入错误程序退出：输入1画圆形，输入2画三角形，输入3画矩形");
return;
}
//使用工厂创建对象
Shape sh = ShapeFactory.create(num);
//调用对象的draw()行为
sh.draw();
}
}
5 抽象（重点）
抽象是建立在多态的基础上的，将所有事物像的行为抽取出来，定义在父类中。例如：Shape类有一个draw()方法
抽象的特征：1 是一个很泛的概念，无法实例化对象(无法创建对象)
2 父类不能new对象，只能将共有的行为抽取到父类中
抽象的关键字：abstract，该关键字可以修饰类、修饰方法。一旦某个类被abstract修饰那么该类叫做抽象类，抽象类通常作为父类，让子类去继承。如果一个子类继承了抽象类那么必须覆盖抽象类中的所有抽象方法。
抽象类中可以定义抽象方法、也可以定义非抽象方法、还可以定义静态属性和非静态属性
抽象类不能使用new关键字创建对象。
1）初识抽象类
注意：如果一个抽象类中没有抽象方法那么将失去意义，因为抽象类通常作为父类，子类去继承抽象类覆写抽象方法。
2）形状的示例
场景：定义一个抽象类Shape作为父类，每个形状都有绘画的行为和清除(clear())的行为, 他们是一个整体，每个形状必须先绘画然后清除
package com.sxt.day02.demo06;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 15:11
* @Version 1.0
*
**/
public abstract class Shape {
/**
* 抽象类不仅仅能够定义抽象方法，还能够定义具体方法，一旦抽象类中定义了具体方法，
* 那么子类可以无条件的使用，前提是具体方法不能私有
*
*/
public void action(){
draw();
clear();
}
/***
*
* 一旦某个方法使用abstract修饰，该方法就是一个抽象方法，抽象方法不能有方法体
* 编译错误：抽象方法不能有方法体
* Abstract methods cannot have a body
*/
// public abstract void draw(){}
public abstract void draw();
public abstract void clear();
}
小结：抽象类中具体方法可以调用抽象方法，上面代码编译期draw()和clear()是父类的方法，运行期由于在工厂中创建了具体类型的对象，所以运行期draw()和clear()调用的是子类的方法。
子类可以覆盖父类的抽象方法，也可以使用父类具体方法，工作中尽量不要覆盖父类的具体方法，只覆盖父类的抽象方法。
工作中如果使用抽象类，抽象类通常作为父类
子类继承父类最后继承抽象类，尽量不要继承具体类
package com.sxt.day02.demo06;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 15:18
* @Version 1.0
**/
// 编译错误：子类继承抽象类，必须覆写抽象类中的抽象方法
// Class 'Circle' must either be declared abstract or implement abstract method 'draw()' in 'Shape
// class Circle extends Shape{
// }
class Circle extends Shape{
/**
* @Override 跟功能无关：告诉我此时子类的draw()方法是覆盖了父类的draw()方法
*/
@Override
public void draw() {
System.out.println("圆形绘画");
}
@Override
public void clear() {
System.out.println("圆形清理");
}
}
package com.sxt.day02.demo06;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 15:30
* @Version 1.0
**/
class Rectangle extends Shape{
@Override
public void draw() {
System.out.println("矩形绘画");
}
@Override
public void clear() {
System.out.println("矩形清理");
}
}
package com.sxt.day02.demo06;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 15:30
* @Version 1.0
**/
class Triangle extends Shape{
@Override
public void draw() {
System.out.println("三角形绘画");
}
@Override
public void clear() {
System.out.println("三角形清理");
}
}
package com.sxt.day02.demo06;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 15:33
* @Version 1.0
**/
public class ShapeFactory {
public static Shape createShape(int index) {
Shape sh = null;
switch (index) {
case 1:
sh = new Circle();
break;
case 2:
sh = new Triangle();
break;
case 3:
sh = new Rectangle();
break;
}
return sh;
}
}
测试类：
package com.sxt.day02.demo07;
import com.sxt.day02.demo06.Shape;
import com.sxt.day02.demo06.ShapeFactory;
import java.util.Scanner;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 15:35
* @Version 1.0
**/
public class Paper {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入数字：输入1画圆形，输入2画三角形，输入3画矩形");
int num = input.nextInt();
// check
if(num<1 || num>3){
System.err.println("输入错误程序退出：输入1画圆形，输入2画三角形，输入3画矩形");
return;
}
// 根据输入的整数创建形状
Shape sh = ShapeFactory.createShape(num);
sh.action();
}
}
6 接口
接口是一个标准，或者说接口是一个协议，如果某个类实现了接口就必须准许接口的标准(协议)
JDK1.8以前接口只能定义常量，定义方法声明，不能定义方法的实现，方法实现必须由子类去覆写
JDK1.8之后，提供了一个default关键字，可以在接口中定义方法的实现
一个类最多只能继承(extends)一个父类
一个类可以实现(implements)N个接口
接口中定义的属性必须赋初始值，也就意味着接口中的属性都是 public static final
JDK1.8之前接口中定义的方法，默认是public abstract
小结：接口使用interface关键字定义，如果子类实现接口必须使用implements
一个子类可以实现多个接口，可以变相的多重继承
接口是一个标准，如果某个类实现接口必须覆盖接口中定义的所有方法，除了default以外
接口和实现类之间的关系？
肯德基和肯德基加盟店之间的关系，加盟店必须实现KFC所有的标准
package com.sxt.day02.demo08;
public interface Shape {
// int num =10;
// 程序运行的时候默认会为你添加 public static final
public static final double CIRCLE_PI = 3.14;
public void draw();
// 接口中没有定义public，jvm运行的时候自动帮你加上 public abstract
// public abstract void clear();
void clear();
// 接口不能定义private和protected
// protected void aac();
}
场景1：定义一个形状接口Shape，改接口只有一个方法draw(), 圆形去实现Shape接口
package com.sxt.day02.demo09;
/**
* 形状是一个接口，也是一个标准，所有实现Shape的子类必须实现接口中所有的方法
*/
public interface Shape {
void draw();
}
package com.sxt.day02.demo09;
import java.sql.SQLOutput;
/**
* @Description Circle 实现Shape接口，必须覆写接口中所有的方法（除了default不用覆写）
* @Author caojie
* @Date 2020/7/22 16:27
* @Version 1.0
**/
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("圆形正在绘画...............");
}
}
package com.sxt.day02.demo09;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:28
* @Version 1.0
**/
public class Test {
public static void main(String[] args) {
Shape sh = new Circle();
sh.draw();
}
}
场景2：定义一个形状接口Shape, 有clear()和draw()方法，定义三个形状分别是圆形、矩形、三角形去实现接口，一次创建10个形状，具体的形状使用随机数产生，1圆形2三角形3矩形
从这里开始看 ！！！！！
package com.sxt.day02.demo10;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:33
* @Version 1.0
**/
public interface Shape {
void draw();
void clear();
/**
* default 修饰的方法是默认实现的方法，子类可以不用实现默认方法
* 实现类可以使用default修饰的方法
*/
public default void action(){
draw();
clear();
}
}
package com.sxt.day02.demo10;
import java.sql.SQLOutput;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:36
* @Version 1.0
**/
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("圆形绘画");
}
@Override
public void clear() {
System.out.println("圆形清除");
}
}
package com.sxt.day02.demo10;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:36
* @Version 1.0
**/
public class Rectangle implements Shape{
@Override
public void draw() {
System.out.println("矩形绘画");
}
@Override
public void clear() {
System.out.println("矩形清除");
}
}
package com.sxt.day02.demo10;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:37
* @Version 1.0
**/
public class Triangle implements Shape{
@Override
public void draw() {
System.out.println("三角形绘画");
}
@Override
public void clear() {
System.out.println("三角形清除");
}
}
package com.sxt.day02.demo11;
import com.sxt.day02.demo10.Circle;
import com.sxt.day02.demo10.Rectangle;
import com.sxt.day02.demo10.Shape;
import com.sxt.day02.demo10.Triangle;
import java.util.Random;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:41
* @Version 1.0
* 1定义形状数组
* 2 创建随机数对象
* 3 通过数字产生形状 1圆形2三角形3矩形
* 4 调用形状的方法
**/
public class Paper {
/*
运行期存储具体的形状
*/
private static Shape [] shapes = new Shape[10];
// 填充数组的元素
static{
Random random = new Random();
for (int i = 0; i < shapes.length ; i++) {
//产生随机数
int num = random.nextInt(3)+1;
switch (num){
case 1:
shapes[i] = new Circle();
break;
case 2:
shapes[i] = new Triangle();
break;
case 3:
shapes[i] = new Rectangle();
break;
}
}
}
public static void main(String[] args) {
// 便利数组的每个元素，调用action()方法
for(Shape sh : shapes){
sh.action();
System.out.println("---------------------------------------");
}
}
}
场景：如果创建的对象是圆形（Circle）除了执行draw()方法和clear()方法之外还要计算面积
如何做？
需要判断Shape对象是否是圆形，如果是将其向下转换为Circle，然后调用Circle的draw()方法
package com.sxt.day02.demo10;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:33
* @Version 1.0
**/
public interface Shape {
void draw();
void clear();
/**
* default 修饰的方法是默认实现的方法，子类可以不用实现默认方法
* 实现类可以使用default修饰的方法
*/
// public default void action(){
// draw();
// clear();
// }
}
package com.sxt.day02.demo10;
import java.sql.SQLOutput;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:36
* @Version 1.0
* 注意：工作中向外界只暴露接口，实现类最好向外界隐藏(不适用public修饰，外界无法new)
**/
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("圆形绘画");
}
@Override
public void clear() {
System.out.println("圆形清除");
}
/**
* 计算面积的方法是圆形独有的，其他子类没有这个方法
* @param radius 半径
* @return 面积
*/
public double calcArea(int radius){
return radius * radius * 3.14;
}
}
package com.sxt.day02.demo10;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:36
* @Version 1.0
**/
public class Rectangle implements Shape{
@Override
public void draw() {
System.out.println("矩形绘画");
}
@Override
public void clear() {
System.out.println("矩形清除");
}
}
package com.sxt.day02.demo10;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:37
* @Version 1.0
**/
public class Triangle implements Shape{
@Override
public void draw() {
System.out.println("三角形绘画");
}
@Override
public void clear() {
System.out.println("三角形清除");
}
}
测试类：
package com.sxt.day02.demo11;
import com.sxt.day02.demo10.Circle;
import com.sxt.day02.demo10.Rectangle;
import com.sxt.day02.demo10.Shape;
import com.sxt.day02.demo10.Triangle;
import java.util.Random;
/**
* @Description TODO
* @Author caojie
* @Date 2020/7/22 16:41
* @Version 1.0
* 1定义形状数组
* 2 创建随机数对象
* 3 通过数字产生形状 1圆形2三角形3矩形
* 4 调用形状的方法
**/
public class Paper {
/*
运行期存储具体的形状
*/
private static Shape [] shapes = new Shape[10];
// 填充数组的元素
static{
Random random = new Random();
for (int i = 0; i < shapes.length ; i++) {
//产生随机数
int num = random.nextInt(3)+1;
switch (num){
case 1:
shapes[i] = new Circle();
break;
case 2:
shapes[i] = new Triangle();
break;
case 3:
shapes[i] = new Rectangle();
break;
}
}
}
public static void main(String[] args) {
// 便利数组的每个元素，调用action()方法
for(Shape sh : shapes){
// sh.action();
sh.draw();
// sh编译期是Shape类型，将强制转换为Circle，强制转换也叫作向下转型
// 向下转型不安全，因为sh编译期是Shape，形状不一定是圆形
// 通常在工作中向下转型之前要做check，判断当前的sh是否是圆形的实例
// 条件成立：表示sh是圆形的实例，执行向下转型
if(sh instanceof Circle){
Circle circle = (Circle)sh;
double area = circle.calcArea(3);
System.out.println("圆形面积="+area);
sh.clear();
}
sh.clear();
System.out.println("---------------------------------------");
}
}
}
7 小结
1 Object类型 所有类型的父类
toString() equals()
2 对象之间的关联
平行关系： has a 学生有车
3 向上转型
编译期父类作为形参，运行期子类可以向上转换为父类
编译期就已经知道对象的类型
4 多态
运行期根据客户传递的参数创建对象，调用恰当的方法
Shape sh;
sh 编译期是父类 运行期根据工厂创建的形状就是一个子类型
5 抽象
抽出向的行为
父类定义做什么，怎么做下沉到子类。目的：做什么和怎么做分离
通常父类定义共性的行为，父类最好不定义属性，所有的属性下沉到子类，因为 圆形和三角形他们的属性不同。
6 接口
接口和抽象类的共性：都是用于父子之间的继承
子类通常使用extends关键字继承父类，使用implements实现接口
一个子类可以实现多个接口
预习：抽象类和接口区别
接口多继承
内部类
垃圾回收