//图形抽象类
public abstract class Shape{    
 public abstract void perimeter();
 public abstract void area();
}
//矩形类
public class Rectangle extends Shape{    
    float length = 10.0f;
float width = 5.0f;
public void perimeter(){
System.out.println("矩形的周长为:"+2*(length+width));
}
public void area(){
System.out.println("矩形的面积为:"+length*width);
}
}
//圆形类
public class Circle extends Shape{    
    float r = 5.0f;
public void area(){
System.out.println("圆形的面积为:"+PI*r*r);
}
public void perimeter(){
System.out.println("圆形的周长为:"+2*PI*r);
}
}
 //测试类
public class Initial{ 
  public static void main(String[] args){
Shape shape1 = new Rectangle();
shape1.perimeter();
shape1.area();
Shape shape2 = new Circle();
shape2.perimeter();
shape2.area();
}
}

引用类型转换：

1、向上类型转换（也叫隐式的或者自动类型转换）， 是小类型到大类型的转换

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

通过 instanceof 关键字 以if为辅助，避免类型转换时出现的错误。

if(animal instanceof Cat){
Cat cat = (Cat)animal;//进行了Cat类型的转换，这个instanceof相当于行了一个判断，
                           返回的布尔类型值，所以用if来配合使用
}else{
    System.out.println("无法进行类型转换");

1、引用的多态，在一个类继承了父类为前提条件下，父类引用可以指向父类和子类，

Animal obj1 = new Animal();

Animal obj2 = new Dog();

这样是可以的。

而反过来子类引用去指向父类是不被允许的：

Dog obj3 = new Animal();

父类指向不同的对象，对应的调用不同对象的方法。

2、方法的多态，创建本类对象时，调用的方法为本类方法；创建子类对象时，调用的方法为子类重写的方法或（如果子类没有重写父类的方法）继承的方法，而且，如果子类中的方法父类并没有，那么父类的引用无法直接使用子类中的方法。

equals()方法：比较的是对象的引用是否指向同一块内存地址、

Dog dog1 = new Dog();

dog1.age = 15;

Dog dog2 = new Dog();

dog2.age = 15;

dog1.equals(dog2)  结果是false

类似于 == 也是判断引用的值是否是同一块内存地址、

Dog other = (Dog)obj; 将传进来的obj强转成Dog类型 并赋值给other

getClass()是类对象   与 类的对象有所区别 。类对象注重的是属性，

而类的对象注重的是 对象的参数值。

Dog dog = new Dog();

System.out.println(dog);

运行结果：com.imooc.Dog@61de33 输出的是内存地址

需要在Dog类中重写 toString()方法，

@Override

public String toString(){

        return "Dog[age="+age+"]";

}

运行结果：Dog[age=20]

子类的构造的过程中必须调用其父类的构造方法。

如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法。

如果显示的调用构造方法，必须在子类的构造方法的第一行。

如果子类的构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。

引用类型转换

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

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

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

java对象

使用对象的步骤：

   1.创建对象：

       类名  对象名  =  new 类名（）；（等号后面就相当于对一个类实例化，将类转到内存。）

   2.使用对象：

         引用对象的属性： 对象名.属性

          引用对象的方法： 对象名.方法名（）;

(注：float型变量赋值时需加f，否则默认浮点数是double型)

static修饰的静态内部类：

1、静态内部类不能直接访问外部类的非静态成员，但可以通过new 外部类().成员 的方式访问

2、如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();运行结果：

内部类中最常见的就是成员内部类，也称为普通内部类：运行结果：从代码中可以看到，成员内部类的使用方法：

1、Inner类定义在Outer类的内部，相当于Outer类的一个成员变量的位置，Inner类可以使用任意访问控制符，如public、protected、private等

2、Inner类中定义的test()方法可以直接访问Outer类中的数据，而不受访问控制符的影响，如直接访问Outer类中的私有属性a

3、定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去new一个内部类对象，即：        内部类 对象名 = 外部类对象.new 内部类();

4、编译上面的程序后，会发现产生了两个.class文件其中，第二个是外部类的.class文件，第一个是内部类的.class文件，即成员内部类的.class文件总是这样：外部类名$内部类名.class

另外：

1、外部类不能之间是有内部类的成员和方法可以先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

 HelloWorld hello = new HelloWorld();

Inner i = hello.new Inner();

通过i.方法名或者i.变量名的方式。

2、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用this关键字运行结果：

即：外部类和内部类具有相同的成员变量，内部类要访问外部类的成员变量，需要这样：Outer.this.b

1、静态方法中可以直接调用同类中的静态变量，但不能直接调用非静态成员。如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

2、在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。

3、静态方法中，不能直接调用非静态方法，需要通过对象来访问非静态方法。

Java中的接口：

抽象类注意事项：

引用类型转换：

继承是多态的基础