重写：

子类从父类继承，父类的一些方法，子类需要修改

所以我们需要重写。

如何重写，

在子类中写一个和父类 修饰符，类型名，方法名，参数类型，参数个数一样的 方法。

Shape

package project5_2;

public abstract class Shape {

public abstract double perimeter(double h,double a) ;

public abstract double area(double h,double a) ;

}

Rectangle

package project5_2;

public class Rectangle extends Shape {

@Override

public double perimeter(double h, double a) {

// TODO Auto-generated method stub

return 2*(h+a);

}

@Override

public double area(double h, double a) {

// TODO Auto-generated method stub

return h*a;

}

}

Circle

package project5_2;

public class Circle extends Shape {

@Override

public double perimeter(double h, double a) {

// TODO Auto-generated method stub

return 2*h*Math.PI;

}

@Override

public double area(double h, double a) {

// TODO Auto-generated method stub

return h*h*Math.PI;

}

}

Test

package project5_2;

public class Test {

public static void main(String[] args) {

// TODO Auto-generated method stub

Shape obj1=new Rectangle();

Shape obj2=new Circle();

double L1=obj1.perimeter(2.5, 4.0);

double S1=obj1.area(2.5, 4.0);

double L2=obj2.perimeter(2.0,0.0);

double S2=obj2.area(3.0, 0);

System.out.println("长方形的周长为："+L1);

System.out.println("长方形的面积为："+S1);

System.out.println("圆形的周长为："+L2);

System.out.println("圆形的面积为："+S2);

}

}

在一个类下面有一个方法

这个方法下面又有一个类

这个类不能使用访问控制符和static，

因为方法内部类不能在外部类的方法以外的地方使用。

多态的时候,两个类 得是继承关系

抽象类：不关注子类的实现，但是约束子类的特征，可以有普通方法

编写父类class文件的时候，勾选abstract，起到约束子类的作用，本章的课后练习不难，自主运行成功，定义pi=3.14

引用类型转换，自动类型转换和强制类型转换（由大到小）

instanceof 判断能否将animal转换为cat，已知

Dog d = new Dog();
 Animal animal = d;

此时animal是Dog类型的，可以转换

  if(d instanceof Dog) {
   Dog d2 = (Dog)animal;

  }else {
   System.out.println("无法进行类型转换，生成Dog类型");
 
  

instanceof 判断能否将animal转换为cat

if (animal instanceof Cat){

  Cat c = (Cat)animal;

 }else {
  System.out.println("无法进行强制转化，生成Cat类型"); }
 }

运行结果：无法进行强制转化，生成Cat类型

内部类为静态，即静态内部类

对外有两种情况

1. 访问外部类的非静态成员

   1. 方法：new 外部类().成员

2. 访问外部类的静态成员

   1. 相同，外部类名.静态成员

                比如Souter.b
      

   2. 不同，直接"成员名"
      

   3. 是否重名 

用静态内部类来创建对象的时候，不关外部对象什么事情，所以只要

内部类名  对象名 = new 内部类名()；

比普通内部类简单

普通内部类是

内部类名  对象名 = 外部类名.new 内部类名();

多态：引用的多态和方法的多态

父类的引用既可以指向本类，又可以指向子类；

Animal a1 = new Animal();

Animal a2 = new Dog();

可以调用本类的方法，子类重写或者继承的方法，

Animal->eat(){}方法  a1.eat(){}

Dog->eat(){}方法 a2.eat(){}

注意：子类特有的方法是不能被调用的（不属于继承而来的方法）

成员内部类  普通内部类

1. 和上一节的内容相似。

    编译之后产生两个 .class 文件

    第一个是内部类的 .class

    第二个是内部类的,  外部类名$内部类名.class 

                        l例如        Outer$Inner.class

    2.如果外部类和内部类是普通的类（没有用static修饰），

    如果外部类和内部类的成员变量或者方法相同，可以利用this来区分。（0static静态类不用this）

public void outer{

int b = 1;

    public void Inner{

    int b =2;

    public void test(){

        System.out.println("Outer:" + Outer.this.b);  //这里打印出1    用this的话，则指外部类

        System.out.println("Inner:" + b);         //这里打印出2    如果不指定，默认是内部类

            }

    }

}

    3.当要内部类去创建一个对象的时候，

            内部类名 对象名 = 外部类名.new 内部类名();

内部类

就是类里面还有类

使用方法：外部类

           直接public class Inner{

     //内部类的方法

         public void show(){

             System.out.println("Inner类");

    }

}

该记住的点：

先创建外部类对象

HellowWorld hello = new HelloWorld();

再创建内部类对象

Inner i =hello.new Inner();

调用内部类对象的方法

i.show();

不同于C#。初始化块类似默认优先无参构造。静态初始化块类似静态构造函数。

抽象类：用abstract关键字修饰

应用场景：

1. 父类只知道子类应该包含怎样的方法，但无法准确知道子类如何实现这些方法，用来约束子类必须有哪些方法，但不关注如何实现

2. 把多个有相同特征的类抽象出一个类，以此为模板

 作用：

限制子类必须实现某些方法，但不关注实现细节

使用规则：

1. abstract定义抽象类

2. abstract定义抽象方法，只需要申明，不需要实现

3. 包含抽象方法的类是抽象类

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

5. 抽象类不能直接创建，可以定义引用变量，指向子类对象

初学者不要误导人

引用类型转换

1.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换

Dog dog=new Dog（）;

Animal animal=dog；向上类型转换

2.向下类型转换（强制类型转换），是大类型到小类型

再将父类类引用转换为子类对象Dog dog2=(Dog)animal;

Cat cat=(Cat)animal;animal已经是Dog类型，编译时是Cat类型，不会报错；运行时是Dog类型，会报错。

可以用if（animal instanceof Cat）{}进行判断animal是否是Cat类型

3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题

1.
IPlayGrame ip3=new IPlayGrame(){
public void playGrame(){
System.out.println("使用匿名内部类的方法是实现接口");}};
ip3.playGrame();
2.
new IPlayGrame(){
public void playGrame(){
System.out.println("使用匿名内部类的方法实现接口");}}.playGrame();