五．面向对象（三） - mooyoo末鱼

3.1 main（）方法

由于java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。

public static void main(String[] args){

//方法体

}

①main()是一个方法，是主方法，为程序的入口

②权限修饰符：public protected 缺省 private ---面向对象的封装性

③对于方法来讲：static final abstract

④方法的返回值：void / 具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return

⑤方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意

⑥形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。形参 & 实参---方法的参数传递机制：值传递

⑦方法体：方法定义的是一种功能，具体的实现由方法体操作。

3.2类的成员之四：代码块

①初始化块(代码块)作用：对Java对象进行初始化

②程序的执行顺序：

③一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块(static block )，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。

④tatic块通常用于初始化static (类)属性

class Person {

public static int total;

static {

total = 100;//为total赋初值

}

…… //其它属性或方法声明

}

⑤非静态代码块：

1)可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)

2)里面可以有输出语句

3)一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行

4)每创建一个类的对象，非静态代码块就加载一次。

5)非静态代码块的执行要早于构造器

⑥静态代码块：

1)里面可以有输出语句

2)随着类的加载而加载，而且只被加载一次

3)多个静态代码块之间按照顺序结构执行

4)静态代码块的执行要早于非静态代码块的执行。

5)静态的代码块中只能执行静态的结构(类属性，类方法)

⑦关于属性赋值的操作：

1)默认的初始化

2)显式的初始化或代码块初始化(此处两个结构按照顺序执行)

3)构造器中；

—————————以上是对象的属性初始化的过程—————————————

4)通过方法对对象的相应属性进行修改

3.3 final关键字

3.3.1 final的定义

在Java中声明类、属性和方法时，可使用关键字final来修饰，表示“最终”。

①final标记的类不能被继承。提高安全性，提高程序的可读性。

String类、System类、StringBuffer类

②final标记的方法不能被子类重写。

Object类中的getClass()。

③final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。

final标记的成员变量不能使用默认初始化，必须在声明的同时或在每个构造方法中或代码块中显式赋值，然后才能使用。final double PI=3.14;

变量用static final修饰：全局常量。比如：Math 类的PI。

④要与finally finalize()区分开。

3.3.2 final基础语法

①final修饰类

final class A{

}

class B extends A{ //错误，不能被继承。

}

中国古代，什么人不能有后代，就可以被final声明，称为太监类

②final修饰方法

class A{

public final void print(){

System.out.println(“A”);

}

class B extends A{

public void print(){ //错误，不能被重写。

System.out.println(“尚硅谷”);

}

③final修饰变量——常量

class A{

private final String INFO = “atguigu”; //声明常量

public void print(){

//INFO = “尚硅谷”;

}

常量名要大写，内容不可修改。——如同古代皇帝的圣旨。

④ final修饰的成员变量：一般和static联用。

class MyMath{

//常量.java规范中要求所有的常量“大写”

//常量：值不可再改变的变量.

public static final double PI = 3.14;

}

⑤关键字final应用举例：

public final class Test{

public static int totalNumber = 5 ;

public final int ID;

public Test(){

ID = ++totalNumber; //可在构造方法中给final变量赋值

}

public static void main(String[] args) {

Test t = new Test();

System.out.println(t.ID);

final int I = 10;

final int J;

J = 20;

J = 30; //非法

}

⑥深入final：

final修饰的引用类型，该引用不可再重新指向其他的java对象。但是fianl修饰的引用，该引用指向的对象的属性是可以修改的。

public class Test02{

public static void main(String[] args){

final Customer c = new Customer("JACK",15);

//c是final的，无法重新赋值。

//c = new Customer("LUCY",20);//Error

c.name = "李四";

c.age = 25;

System.out.println(c.name);

System.out.println(c.age);

}

class Customer{

String name;

int age;

Customer(String name,int age){

this.name = name;

this.age = age;

}

3.4抽象：abstract

3.4.1什么是抽象类？

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

3.4.2抽象类基础语法

①用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。

②如何定义抽象类?

class关键字前加abstract。不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。

③抽象类无法被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

④虽然抽象类没有办法实例化，但是抽象类也有构造方法，该构造方法是给子类创建对象用的。

⑤抽象类中可以定义抽象方法.

抽象方法的语法：只有方法的声明，没有方法的实现。在方法的修饰符列表中添加abstract关键字.并且抽象方法应该以“;”结束,不能带有“{}”。例如：public abstract void m1();

⑥抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中。含有抽象方法的类必须被声明为抽象类。

⑦一个非抽象的类继承抽象类，必须将抽象类中的抽象方法覆盖，实现，重写。

⑧抽象类不能被final修饰，抽象方法不能被final修饰。

3.4.3抽象类举例

abstract class A{

abstract void m1( );

public void m2( ){

System.out.println("A类中定义的m2方法");

}

class B extends A{

void m1( ){

System.out.println("B类中定义的m1方法");

}

public class Test{

public static void main( String args[ ] ){

A a = new B( );

a.m1( );

a.m2( );

}

3.4.4思考

①为什么抽象类不可以使用final关键字声明？

abstract类一定要能被继承，而final类不能被继承

②一个抽象类中可以定义构造器吗？

//abstract 不能用来修饰属性、构造器、private、final、static

public class TestAbstract1 {

}

abstract class A1{

//abstract int name;

//因为构造器不能被重写

// public abstract A1(){

// }

//子类不能覆盖（或重写）声明为private的方法的。

//private abstract void method1();

// final修饰的方法不能重写

// public abstract final void method2();

// public abstract static void method3();

// static修饰的方法可以用类来调，但是abstract 的方法又没有方法体。。。

}

注意：

1)当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化。

2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。

3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个"实体类",即可以实例化。

4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！

③模板方法设计模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题：

当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

public class TestTemplate {

public static void main(String[] args) {

new SubTemplate().spendTime();

}

abstract class Template {

public abstract void code();

public void spendTime() {

long start = System.currentTimeMillis();

this.code();

long end = System.currentTimeMillis();

System.out.println("花费的时间为：" + (end - start));

}

class SubTemplate extends Template {

public void code() {

boolean flag = false;

for(int i = 2;i <= 10000;i++){

for(int j = 2;j <= Math.sqrt(i);j++){

if(i % j == 0){

flag = true;

break;

}

if(!flag){

System.out.println(i);

}

flag = false;

}

3.5接口interface

①有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

②接口(interface)是抽象方法和常量值的定义的集合。

③从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

3.5.1接口基础语法：

接口也是一种引用类型，可以等同看做类.

①如何定义接口，语法：

[修饰符] interface 接口名{}

②接口中只能出现：常量、抽象方法。

接口中的所有成员变量都默认是由public static final修饰的。

接口中的所有方法都默认是由public abstract修饰的。

③接口其实是一个特殊的抽象类，特殊在接口是完全抽象的。

④接口中没有构造方法，无法被实例化。

⑤接口和接口之间可以多继承。

⑥一个类可以实现多个接口。(这里的“实现”可以等同看做“继承”)

⑦一个非抽象的类实现接口，需要将接口中所有的方法“实现/重写/覆盖”，方可实例化。否则，仍为抽象类。

⑧如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类

⑨接口的主要用途就是被实现类实现。（面向接口编程）

与继承关系类似，接口与实现类之间存在多态性。

定义Java类的语法格式：先写extends，后写implements

public interface A{

//常量(必须用public static final修饰)

public static final String SUCCESS = "success";

public static final double PI = 3.14;

byte MAX_VALUE = 127; //常量//public static final是可以省略的。

//抽象方法(接口中所有的抽象方法都是public abstract)

public abstract void m1();

void m2();//public abstract是可以省略的。

}

interface B{

void m1();

}

interface C{

void m2();

}

interface D{

void m3();

}

interface E extends B,C,D{

void m4();

}

//implements是实现的意思，是一个关键字.

//implements和extends意义相同。

class MyClass implements B,C{

public void m1(){}

public void m2(){}

}

class F implements E{

public void m1(){}

public void m2(){}

public void m3(){}

public void m4(){}

}

3.5.2接口的作用

①可以使项目分层，所有层都面向接口开发，开发效率提高了。

②接口使代码和代码之间的耦合度降低，就像内存条和主板的关系，变得“可插拔”。可以随意切换。

③接口和抽象类都能完成某个功能，优先选择接口。因为接口可以多实现，多继承。并且一个类除了实现接口之外，还可以去继承其他类（保留了类的继承）。

举例1：

public interface CustomerService{

//定义一个退出系统的方法

void logout();

}

/* 编写接口的实现类.

该类的编写完全是面向接口去实现的。

*/

public class CustomerServiceImpl implements CustomerService{

//对接口中的抽象方法进行实现。

public void logout(){

System.out.println("成功退出系统！");

}

public class Test{

//入口

public static void main(String[] args){

//要执行CustomerServiceImpl中的logout方法.

//以下程序面向接口去调用

CustomerService cs = new CustomerServiceImpl(); //多态

//调用

cs.logout();

}

举例2：

/*

汽车和发动机之间的接口。

生产汽车的厂家面向接口生产。

生产发动机的厂家面向接口生产。

*/

public interface Engine{

//所有的发动机都可以启动.

void start();

}

//生产汽车

public class Car{

//Field

//引擎

//面向接口编程

Engine e;

//Constructor

Car(Engine e){

this.e = e;

}

//汽车应该能够测试引擎

public void testEngine(){

e.start();//面向接口调用

}

public class YAMAHA implements Engine{

public void start(){

System.out.println("YAMAHA启动");

}

public class HONDA implements Engine{

public void start(){

System.out.println("HONDA启动");

}

public class Test{

public static void main(String[] args){

//1.生产引擎

YAMAHA e1 = new YAMAHA();

//2.生产汽车

Car c = new Car(e1);

//3.测试引擎

c.testEngine();

//换HONDA

c.e = new HONDA();

c.testEngine();

}

3.5.3接口的应用：工厂方法(FactoryMethod)& 代理模式(Proxy)

①工厂方法(FactoryMethod)

概述：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

适用性：

1)当一个类不知道它所必须创建的对象的类的时候

2)当一个类希望由它的子类来指定它所创建的对象的时候

3)当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候

工厂方法举例：

总结：

FactoryMethod模式是设计模式中应用最为广泛的模式，在面向对象的编程中，对象的创建工作非常简单，对象的创建时机却很重要。FactoryMethod解决的就是这个问题，它通过面向对象的手法，将所要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。

//接口的应用：工厂方法的设计模式

public class TestFactoryMethod {

public static void main(String[] args) {

IWorkFactory i = new StudentWorkFactory();

i.getWork().doWork();

IWorkFactory i1 = new TeacherWorkFactory();

i1.getWork().doWork();

}

interface IWorkFactory{

Work getWork();

}

class StudentWorkFactory implements IWorkFactory{

@Override

public Work getWork() {

return new StudentWork();

}

class TeacherWorkFactory implements IWorkFactory{

@Override

public Work getWork() {

return new TeacherWork();

}

interface Work{

void doWork();

}

class StudentWork implements Work{

@Override

public void doWork() {

System.out.println("学生写作业");

}

class TeacherWork implements Work{

@Override

public void doWork() {

System.out.println("老师批改作业");

}

②代理模式(Proxy)

概述：

为其他对象提供一种代理以控制对这个对象的访问。

interface Object{

void action();

}

class ProxyObject implements Object{

Object obj;

public void action(){

System.out.println("代理开始");

obj.action();

System.out.println("代理结束");

}

public ProxyObject(){

System.out.println("这是代理类");

obj = new ObjectImpl();

}

class ObjectImpl implements Object{

public void action(){

System.out.println("======");

System.out.println("被代理的类");

System.out.println("======");

}

public class Test2 {

public static void main(String[] args) {

Object ob = new ProxyObject();

ob.action();

}

//接口的应用：代理模式（静态代理）

public class TestProxy {

public static void main(String[] args) {

Object obj = new ProxyObject();

obj.action();

}

interface Object{

void action();

}

//代理类

class ProxyObject implements Object{

Object obj;

public ProxyObject(){

System.out.println("代理类创建成功");

obj = new ObjctImpl();

}

public void action(){

System.out.println("代理类开始执行");

obj.action();

System.out.println("代理类执行结束");

}

//被代理类

class ObjctImpl implements Object{

@Override

public void action() {

System.out.println("=====被代理类开始执行======");

System.out.println("=====具体的操作======");

System.out.println("=====被代理类执行完毕======");

}

3.6 类的成员之五：内部类

3.6.1 静态内部类

①静态内部类可以等同看做静态变量。

②内部类重要的作用：可以访问外部类中私有的数据。

③静态内部类可以直接访问外部类的静态数据,无法直接访问成员。

④静态内部类不会持有外部的类的引用，创建时可以不用创建外部类，静态内部类可以直接访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

public class OuterClass{

//静态变量

private static String s1 = "A";

//成员变量

private String s2 = "B";

//静态方法

private static void m1(){

System.out.println("static's m1 method execute!");

}

//成员方法

private void m2(){

System.out.println("m2 method execute!");

}

//静态内部类

//可以用访问控制权限的修饰符修饰。

//public,protected,private,缺省

static class InnerClass{

//静态方法

public static void m3(){

System.out.println(s1);

m1();

//System.out.println(s2);

//m2();

}

//成员方法

public void m4(){

System.out.println(s1);

m1();

//System.out.println(s2);

//m2();

}

//入口

public static void main(String[] args){

//执行m3

OuterClass.InnerClass.m3();

//执行m4

InnerClass inner = new OuterClass.InnerClass();

inner.m4();

}

3.6.2 成员内部类

①成员内部类可以等同看做成员变量

②成员内部类中不能有静态声明

③成员内部类可以访问外部类所有的数据

public class OuterClass{

//静态变量

private static String s1 = "A";

//成员变量

private String s2 = "B";

//静态方法

private static void m1(){

System.out.println("static's m1 method execute!");

}

//成员方法

private void m2(){

System.out.println("m2 method execute!");

}

//成员内部类

//可以用访问控制权限的修饰符修饰。

//public,protected,private,缺省

class InnerClass{

//静态方法

//public static void m3(){}

//成员方法

public void m4(){

System.out.println(s1);

m1();

System.out.println(s2);

m2();

}

//入口

public static void main(String[] args){

//创建外部类对象

OuterClass oc = new OuterClass();

InnerClass inner = oc.new InnerClass();

inner.m4();

}

3.6.3 局部内部类

①局部内部类等同于局部变量

②重点：局部内部类在访问局部变量的时候，局部变量必须使用final修饰

③局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样

局部内部类和成员内部类一致，不能包含静态成员

public class OuterClass{

//方法

public void m1(){

//局部变量

final int i = 10;//

//局部内部类

//局部内部类不能用访问控制权限修饰符修饰。

class InnerClass{

//内部类不能有静态声明

//public static void m1(){}

//成员方法

public void m2(){

System.out.println(i); // 10

}

//调用m2

InnerClass inner = new InnerClass();

inner.m2();

}

//入口

public static void main(String[] args){

OuterClass oc = new OuterClass();

oc.m1();

}

3.6.4 匿名内部类

是一种特殊的内部类，该类没有名字

public class Test{

//静态方法

public static void t(CustomerService cs){

cs.logout();

}

//入口

public static void main(String[] args){

//调用t方法

//t(new CustomerServiceImpl());

//使用匿名内部类的方式执行t方法

//整个这个"new CustomerService(){}"就是个匿名内部类

t(new CustomerService(){

public void logout(){

System.out.println("exit!");

}

});

//匿名内部类的优点：少定义一个类.

//缺点：无法重复使用!

}

//接口

interface CustomerService{

//退出系统

void logout();

}

//编写一个类实现CustomerService接口

/*

class CustomerServiceImpl implements CustomerService{

public void logout(){

System.out.println("系统已经安全退出！");

}

*/

3.7 类之间的关系

3.7.1 泛化关系

类和类之间的继承关系及接口与接口之间的继承关系。

3.7.2 实现关系

类对接口的实现。

3.7.3 关联关系

类与类之间的连接，一个类可以知道另一个类的属性和方法，在java 语言中使用成员变量体现。

Me

public class Me{

String name; //Field

//在当前类中含有其他类的引用。

//在当前对象中含有指向其他对象的引用。

//朋友

Friend f; //Me和Friend就是关联关系

Me(Friend f){

this.f = f;

}

Friend

public class Friend{

//Field

String name;

String addr;

String tel;

Friend(String addr){

this.addr = addr;

}

Test

public class Test{

public static void main(String[] args){

Friend f = new Friend("北京朝阳");

//建立关联关系

Me m = new Me(f);

//通过m可以获取朋友的住址

System.out.println(m.f.addr);

}

3.7.4 聚合关系

是关联关系的一种，是较强的关联关系，是整体和部分的关系，如：汽车和轮胎，它与关联关系不同，关联关系的类处在同一个层次上，而聚合关系的类处在不平等的层次上，一个代表整体，一个代表部分，在java 语言中使用实例变量体现。

Classroom

//ClassRoom就是整体

public class ClassRoom{

//ClassRoom和List集合属于关联关系.在同一个层级上.

//ClassRoom和Student属于聚合关系，一个是整体，一个是部分.

List<Student> stus; //Student就是部分.

//聚合关系：整体不依赖部分，部分也不会依赖整体。

//整体无法决定部分的生命周期。

}

Student

public class Student{

}

3.7.4 合成关系

是关联关系的一种，比聚合关系强的关联关系，如：人和四肢，整体对象决定部分对象的生命周期，部分对象每一时刻只与一个对象发生合成关系，在java 语言中使用实例变量体现。

人

public class 人{

//人和List是关联关系.

//人和四肢是合成关系，人是整体，四肢是部分.

//合成关系和聚合关系是相似的，区别的地方在：整体和部分是紧密相连的

//整体的生命周期决定部分的生命周期。

List<四肢> s;

}

四肢

public class 四肢{

}

3.7.5 依赖关系

依赖关系是比关联关系弱的关系，在java 语言中体现为返回值，参数，局部变量和静态方法调用。

Test

public class Test{

public void m1(){

//局部变量

User u = new User(); //依赖关系.

}

User

class User{

}

3.8 is-a、is-like-a、has-a

3.8.1 is-a（类和类之间的继承关系，泛化关系）

public class Animal{

public void method1() ;

}

public class Dog extends Animal { //Dog is a Animal

}

3.8.2 is-like-a（类对接口的实现，类和接口之间的关系，实现关系）

public interface I {

public void method1() ;

}

public class A implements I { //A is like a I;

public void method1() {

//实现

}

3.8.3 has-a（A中包含B，关联关系）

public class A { //A has a B;

private B b;

}

public class B {

}

总结：

面向对象的三条主线：

一、类及类的成分

1.类与类的关系：

java程序是关注于类的设计。

类从代码的角度：并列关系！

从执行、设计的角度：关联关系、继承关系、聚合关系

class A{

}

class B{

A a = new A();

}

2.类的成分：属性方法构造器代码块内部类

2.1 属性：

①变量的分类：成员变量（属性 Field）vs 局部变量(方法的形参、方法内部、代码块内部)

②数据类型：基本数据类型（8种，不同的数据类型对应不同的默认初始化值vs 引用数据类型（数组、类、接口默认初始化值为null）

③属性的声明格式：修饰符数据类型变量名 = 初始化值；//java是强数据类型的语言

④对属性的赋值的操作：默认初始化、显式的初始化、代码块的初始化、构造器的初始化、调用方法或属性进行赋值

2.2 方法

①格式：修饰符（其它的关键字：static/final/abstract）返回值类型方法名（形参列表）{

//方法体 }

②方法的重载(overload) vs 方法的重写(override overwrite)

③ 方法的参数传递机制：值传递（难点）

2.3构造器

①构造器的作用：1.创建类的对象 2.初始化对象的成员变量

②构造器也是可以重载的。

2.4 代码块

①主要作用：用来初始化类的成员变量

②分类：静态的代码块 vs 非静态的代码块

2.5 内部类

①分类：成员内部类（static的成员vs 非static的成员）vs 局部内部类（方法内部声明的类）

②掌握 :如何创建成员内部类的对象（如：创建Bird类和Dog类的对象）、如何区分调用外

部类或内部类的变量(尤其是变量重名时)、局部内部类的使用（见TestInnerClass1.java）

3. 类的初始化（创建类的对象）

3.1 如何创建类的对象。

如： Person p = new Person(); Date d = new Date();

3.2 内存解析：

①栈：局部变量、对象的引用名、数组的引用名

堆：new 出来的“东西”

方法区：（字符串常量池）

静态域：存放类中静态的变量

②如何理解创建的对象在内存中加载的过程（理解）

3.3 子类对象实例化的全过程： SubClass sc = new SubClass();

二、面向对象的三大特性：

1.封装性：

① 通过私有化类的成员变量，通过公共的getter和setter方法来调用和修改

② 还可以对类的其他结构进行“封装”

③ 权限修饰符：public protected 缺省 private

2.继承性：

①通过让一个类A继承另一个类B，就可以获取类B中的结构（主要的：属性、方法、构造器）。子类：类A 父类：类B

②java中的类的继承性：单继承的。

3.多态性：

①体现：方法的重载与重写；子类对象的多态性 Person p = new Student();

②子类对象多态性的使用：虚拟方法调用。

③向上转型向下转型 Student s = (Student)p;

//建议在向下转型之前： if ( p instanceof Student)避免出现ClassCastException的异常

三、其它关键字：

1.this:修饰属性、方法、构造器。表示：当前对象或当前正在创建的对象。

2.super:修饰属性、方法、构造器。显式的调用父类的相应的结构，尤其是子父类有重名的方法、属性

3.static :修饰属性、方法、代码块、内部类。随着类的加载而加载！

4.final:修饰类、属性、方法。表示“最终的”

5.abstract:修饰类、方法

6. interface:表示是一个接口，（接口是与类并列的一个结构）。类与接口之间同时“implements”发生关系。

7.package import …

8.abstract:不能修饰属性、构造器、不能与final static private共用。