在Java中，多态的前提是继承

多态

   引用多态：

                 1.父类的引用可以指向本类的对象

                 2.父类的引用可以指向一个子类对象

                  注：子类的引用不能指向父类对象

    方法多态：

                    1.创建本类对象时，调用的方法为本类方法

                    2.创建子类对象时，调用的方法为子类重写的方法或者继                           承的方法

package com.learn.polymorphic;

public class TestAbstract {

    public static void main(String[] args) {
        Shape shapeRectangle = new Rectangle(10,20);
        System.out.println("长为：10");
        System.out.println("高为：20");
        System.out.println("矩形周长："+shapeRectangle.perimeter());
        System.out.println("矩形面积："+shapeRectangle.area());

        System.out.println("------------->");

        Shape shapeCircle = new Circle(6);
        System.out.println("半径为：6 的圆形");
        System.out.println("周长："+shapeCircle.perimeter());
        System.out.println("面积："+shapeCircle.area());

    }


}

/**
 * 图形类
 */
abstract class Shape{

    private double sideLength;        //边长
    private double height;            //高

    private double r; //声明半径
    private final double PI = 3.14;    //声明π

    Shape(double sideLength,double height){
        this.sideLength = sideLength;
        this.height = height;
    }

    Shape(double r){
        this.r = r;
    }

    //计算周长
    public abstract double perimeter();

    //计算面积
    public abstract double area();


    public double getSideLength() {
        return sideLength;
    }

    public void setSideLength(double sideLength) {
        this.sideLength = sideLength;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getR() {
        return r;
    }

    public void setR(double r) {
        this.r = r;
    }

    public double getPI() {
        return PI;
    }
}

/**
 * 矩形
 */
class Rectangle extends Shape{

    Rectangle(double sideLength, double height) {
        super(sideLength, height);
    }

    @Override
    public double perimeter() {
        return (getSideLength()+getHeight())*2;
    }

    @Override
    public double area() {
        return getSideLength()*getHeight();
    }

}

/**
 * 圆形
 */
class Circle extends Shape{

    Circle(double r) {
        super(r);
    }

    @Override
    public double perimeter() {
        return 2*getPI()*getR();
    }

    @Override
    public double area() {
        return getPI()*Math.pow(getR(),2);
    }

}

equals（）方法它比较的是对象的引用是不是指向同一块的内存地址

一般情况下比较两个对象时比较他的值是不是一致，所以要进行重写

new的意思就是开辟内存地址，创建对象

java中的访问修饰符范围

内部类：
1.内部类是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

2.作用：

内部类提供了更多的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类；

内部类的可以直接访问外部类的所有数据，包括私有的数据；

内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便；

3.内部类的分类：

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

package com.learn.polymorphic;

public class Transportation {

    public void way(int num){
        System.out.println("运算方式............");
    }

}

class Bus extends Transportation{

    @Override
    public void way(int num) {
        System.out.println("陆运............."+num);
    }

}

class Ship extends Transportation{

    @Override
    public void way(int num) {
        System.out.println("海运............."+num);
    }

}

class Aircraft extends Transportation{

    @Override
    public void way(int num) {
        System.out.println("空运............."+num);
    }

}

class TestTransportation{
    public static void main(String[] args) {
        Transportation transportation = new Aircraft();
        transportation.way(300);
        Transportation bus = new Bus();
        bus.way(40);
        Transportation ship = new Ship();
        ship.way(200);
    }
}

访问修饰符：

private:本类

默认：本类、本包

protected:本类、本包、子类

public:本类、本包、子类、其他

包：
1.管理java文件；解决同名文件冲突

2.定义包

package 包名

注：必须放在java源程序的第一行；包名间可用“.”号隔开(区分层次)；

     eg：com.imooc.MyClass

             com.imooc.*

3.包的使用

  使用import关键字；

  命名规范是全小写字母拼写;

  使用时可以加载某个包下的所有文件，也可加载某个具体子包下的所有文件;

程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次

方法的重写

1、概念：如果子类对继承的父类的方法不满意，可以重写父类继承的方法，当调用时会优先调用子类重写的方法。

2、语法：

a、返回值类型

b、方法名

c、参数类型及个数

都必须与父类继承的方法相同，才称为方法的重写!

继承（extends）

1、概念：继承强调类与类之间的一种关系，是一种“is a”的关系

例如：狗是一种动物——狗继承了动物 

其中：动物是父类（基类）

          狗是子类（派生类）

注意： Java中继承关系是单继承的，即一个类只有一个父类

2、继承的好处：

      子类可以继承父类的属性和方法

      从而实现代码的复用！

注意：父类的属性和方法的修饰符不能是private，否则无法被子类继承！

3、语法：

class  子类  extends  父类 {

............

}

例如：class  Dog  extends  Animal{

          ............

          }

这边需要自己动手做一下

1、包含抽象方法的类是抽象类

2、抽象类中可以包含普通的方法，也可以没有抽象方法