final关键字： 表示“最终的”，即不可修改。 final可以修饰类、方法、属性和变量 1、修饰类：不允许被继承 2、修饰方法：不允许被重写 3、修饰属性：则该属性不会进行隐式初始化（不会自动初始化），需要手动初始化或者在构造方法中初始化 （但二者只能选一，即只能初始化一次后便不能更改） 4、修饰变量，只能在声明的时候赋一次值，成为常量。 （static final 会使其成为全局常量）

不能用父类的引用指向子类独有的方法

静态内部类是 static 修饰的内部类，这种内部类的特点是：

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

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

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

学习JAVA第四天，保持热情最重要。

 形状   抽象父类

package com.imooc;

public abstract class Shape {

public abstract void zhouChang();

public abstract void mianJi();

}

000000000000000000000000000000000000000000000000000000000000

圆形   子类

package com.imooc;

public class Circle extends Shape {

    int r=100;

public void zhouChang() {

float zC=2*(3.14f*r);

System.out.println("当⚪的半径为"+r+"cm,圆周率取3.14时，该⚪的周长为"+zC+"cm");

}

public void mianJi() {

float mJ=(3.14f*r)*r;

System.out.println("当⚪的半径为"+r+"cm,圆周率取3.14时，该⚪的面积为"+mJ+"cm²");

}

}

000000000000000000000000000000000000000000000000000000000000

矩形  子类

package com.imooc;

public class Rctangle extends Shape {

     int bianchang1=167;

         int bianchang2=166;

public void zhouChang() {

int zC=2*(bianchang1+bianchang2);

     System.out.println("当矩形长,宽,分别为"+bianchang1+"cm,"+bianchang2+"cm时,周长为"+zC+"cm");

}

public void mianJi() {

int mJ=bianchang1*bianchang2;

     System.out.println("当矩形长,宽,分别为"+bianchang1+"cm,"+bianchang2+"cm时,面积为"+mJ+"cm²");

}

}

0000000000000000000000000000000000000000000000000000000000000

主函数intial应用类

package com.imooc;

public class Initial {

public static void main(String[] args) {

        Shape sha1=new Rctangle();

        Shape sha2=new Circle();

        sha1.zhouChang();

        sha2.zhouChang();

        sha1.mianJi();

        sha2.mianJi();

}

}

000000000000000000000000000000000000000000000000000000000000

运行结果

当矩形长,宽,分别为167cm,166cm时,周长为666cm。

当⚪的半径为100cm,圆周率取3.14时，该⚪的周长为628.0cm。

当矩形长,宽,分别为167cm,166cm时,面积为27722cm²。

当⚪的半径为100cm,圆周率取3.14时，该⚪的面积为31400.0cm²。

Java 中的静态内部类

静态内部类是 static 修饰的内部类，这种内部类的特点是：

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

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

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

运行结果 ： 

啪啪租车系统 代码1： http://hubojing.github.io/2017/03/18/%E8%BE%BE%E8%BE%BE%E7%A7%9F%E8%BD%A6%E7%B3%BB%E7%BB%9F%EF%BC%88Java%E5%AE%9E%E7%8E%B0%EF%BC%89/ 代码2： http://www.imooc.com/article/16922 代码3： www.imooc.com/article/16880 代码4： 参考了代码http://blog.csdn.net/Joseph_Cherry/article/details/60530978 自己的项目https://code.csdn.net/example440982/dadacar/tree/master 代码5： http://www.imooc.com/article/16652%20%20%20Java 运用接口： 1，http://www.imooc.com/article/16376 2，http://www.imooc.com/article/17018

Java 中的成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码：

运行结果为：

从上面的代码中我们可以看到，成员内部类的使用方法：

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

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

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

4、 编译上面的程序后，会发现产生了两个 .class 文件

其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

另外，友情提示哦：

1、 外部类是不能直接使用内部类的成员和方法滴

可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

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

运行结果：

接口=全局常量+公共的抽象方法； 接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。 2.接口用interface定义，语法： [修饰符] interface 接口名 [extends 父接口1，父接口2……] {//中括号中为可选项 零个到多个常量定义…… 零个到多个抽象方法的定义 } 3.接口就是用来被继承、被实现的，修饰符一般建议用public，不能使用private和protected修饰接口。 4.接口中的属性是常量（public static final修饰），系统会自动加上 5.接口中的方法只能是抽象方法（public abstract修饰），系统会自动加上 6.使用接口：一个类可以实现一个或多和接口，实现接口使用implements关键字。java中一个类只能继承一个父类，可以通过实现多个接口作补充 7.继承父类实现接口的语法： [修饰符] class 类名 extends 父类 implements 接口1，接口2……{ 类体部分}//如果继承的是抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法 如果要继承父类，继承父类必须在实现接口之前 接口命名时首字母为I，以区分类名。可通过add继承父接口 8.实现时可以利用接口的引用指向实现了接口的对象，调用其方法，如 ： IPlay ip1=new Psp();ip1.playGame(); 9.接口的使用还经常与匿名内部类配合（匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称） 语法格式： Interface i=new Interface(){ public void method(){ System.out.print("匿名内部类实现接口的方式……");}} //即通过创建接口的对象，直接写出实现的方法，再调用此方法 还可以直接创建并调用方法，如： new IPlay(){ public void playGame(){ System.out.println("……");}}.playGame();

继承父类实现接口的语法

接口的基本语法

引用类型转换： 1.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换。 如：Dog dog=new Dog();Animal animal=dog;//正确，自动类型提升，向上类型转换 2.向下类型转换（强制类型转换），是大类型到小类型的转换（存在风险，溢出） 如：Dog dog1=(Dog)animal;//向下类型转换 3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。如： Dog dog=new Dog(); Animal animal=dog; Cat cat=(Cat)animal;//编译时不会出错（按Cat类型进行编译），但运行时会报错，因为它开辟的是Dog类型的空间，而（无法将引用类型进行转换）无法将dog对象转换成Cat类型，并且此方法对程序的安全性有影响。此时应该利用instanceof和if语句结合使用，进行验证，以保证程序的安全性，如： if(animal instanceof Cat){//判断animal类中是否包含Cat类型的元素，若包含则进行转换，instanceof返回值为布尔类型 Cat cat=(Cat)animal;}else{ System.out.println("无法进行类型转换");}

instance的作用是判断其左边对象是否为其右边类的实例

多态： 指的是对象的多种形态 主要分为 引用多态 、方法多态 继承是多态的实现基础，别忘了子父类要有继承关系. 多态特性： 一、引用多态 1.父类引用可以指向本类对象 Animal obj1 = new Animal(); 2.父类引用可以指向子类对象 Animal obj2 = new Dog(); 但是我们不能用子类的引用指向父类对象 Dog obj3 = new Animal();//错 二、方法多态 1.在父类Animal中定义一个eat()方法，输出一个语句(动物有吃的能力); 在子类Dog中重写eat()方法，输出一个语句（狗是吃肉的）; 那么我们在测试类main函数里面，如果obj1.eat() ，那么调用的是父类的方法. 若用obj2调用eat()方法，那么调用的是子类的方法. 2.还有一种情况，比如创建一个继承父类Animal的子类Cat ，但是Cat里并不重写继承的eat()方法. 然后，我们在测试类main函数里创建一个子类对象, Animal obj3 = new Cat(); 然后调用 obj3.eat(); 那么，结果调用的则是子类继承父类的方法. (输出结果：动物有吃的能力) 3.最后一种特殊情况，多态的特性是不能使用的. 若在子类添加一个独有的方法 public void watchDoor() ，含有一句输出语句(狗具有看门的能力); 那么我们在测试类的main函数当中(得先定义好对象Animal obj2 = new Dog() )，就不能用obj2.watchDoor()，即不能通过父类的引用调用子类的方法.

1. 数据模型分析：通过对现实世界的事与物主要特征的分析、抽象，为信息系统的实施提供数据存取的数据结构以及相应的约束。

2. 业务模型分析：设计应用程序之前，应该明确应用程序必须执行哪些任务。

3. 显示和流程分析：

   显示：用户可以看到的信息提示界面

   流程：显示信息的执行过程、步骤

属性用private 修饰

方法用public 修饰