1.final 关键字

final关键字可以用来修饰类，方法，成员变量

（1）final标记的类不能被继承;

（2）final标记的方法不能被子类复写;

（3）final标记的变量即成为常量,只能被赋值一次.

final标记的变量名的所有单词必须大写

2.抽象类

2.1抽象类的定义必须先讲抽象方法的定义. 所谓抽象方法,是指只声明而未实现(即没有{}包围的方法体)的方法. 而含有一个或多个抽象方法的类就称为抽象类.

抽象类 = 普通类 + 抽象方法

对于抽象类， 抽象类是不能够直接实例化的, 如果要使用一个抽象类,就必须要有该抽象类的子类. 如果抽象类的子类不是抽象类的话,就一定要复写该抽象类的所有抽象方法.

abstract class Person

{

//全局常量的命名一定要采取全部字母大写的方式

public static final String NAME = "newsainton";

//print()方法有方法体,所以不是抽象方法

public void print()

{

System.out.println("非抽象方法中,Name = "+NAME);

}

//fun()方法不含方法体,为抽象方法

public abstract void fun();

}

//B类继承自A类,但B未声明为抽象类,则必须要复写A类中所有的抽象方法

class Student extends Person

{

public void fun()

{

System.out.println("抽象方法中,Name = "+super.NAME);

}

}

public class Demo01

{

public static void main(String args[])

{

Student s = new Student();

s.fun();

s.print();

}

}

abstract class Person

{

//全局常量的命名一定要采取全部字母大写的方式

public static final String NAME = "newsainton";

//print()方法有方法体,所以不是抽象方法

public void print()

{

System.out.println("非抽象方法中,Name = "+NAME);

}

//fun()方法不含方法体,为抽象方法

public abstract void fun();

}

//B类继承自A类,但B未声明为抽象类,则必须要复写A类中所有的抽象方法

class Student extends Person

{

public void fun()

{

System.out.println("抽象方法中,Name = "+super.NAME);

}

}

public class Demo01

{

public static void main(String args[])

{

Student s = new Student();

s.fun();

s.print();

}

}

2.2抽象类中允许有自己的构造方法,但是该构造方法并不能直接实例化自己的对象. 如果在抽象类中存在有参构造方法,则必须在子类中明确的使用super([参数列表])指明要调用父类中的哪个构造方法.

abstract class Person

{

// 应该有姓名和年龄属性

private String name ;

private int age ;

public Person(){}

// 如果已经不是无参的，则必须在子类中明确调用无参构造

public Person(String name,int age)

{

this.name = name ;

this.age = age ;

}

public String getName()

{

return this.name ;

}

public int getAge()

{

return this.age ;

}

// 定义一个输出方法，但是此方法为抽象方法

public abstract String getInfo() ;

}

class Student extends Person

{

public Student(String name,int age)

{

// 调用Person类中有两个参数的构造方法

super(name,age) ;

}

public String getInfo()

{

return "姓名 = "+super.getName()+"，年龄 = "+super.getAge() ;

}

}

public class Demo05

{

public static void main(String args[])

{

Student s = new Student("张三",30) ;

System.out.println(s.getInfo()) ;

}

}

abstract class Person

{

// 应该有姓名和年龄属性

private String name ;

private int age ;

public Person(){}

// 如果已经不是无参的，则必须在子类中明确调用无参构造

public Person(String name,int age)

{

this.name = name ;

this.age = age ;

}

public String getName()

{

return this.name ;

}

public int getAge()

{

return this.age ;

}

// 定义一个输出方法，但是此方法为抽象方法

public abstract String getInfo() ;

}

class Student extends Person

{

public Student(String name,int age)

{

// 调用Person类中有两个参数的构造方法

super(name,age) ;

}

public String getInfo()

{

return "姓名 = "+super.getName()+"，年龄 = "+super.getAge() ;

}

}

public class Demo05

{

public static void main(String args[])

{

Student s = new Student("张三",30) ;

System.out.println(s.getInfo()) ;

}

}

3.接口：

3.1接口是抽象方法与常量的结合

接口的定义方式为: interface 接口名 { 数据类型 常量名 = 常量值; 返回值类型 方法名(); .......}

在Java中,一个类只能继承一个类,但是却可以实现(implements)多个接口. 如果实现接口的类不是抽象类的话,则该子类必须复写接口中所有的抽象方法.

interface Person

{

//接口中包含了抽象类和抽象方法

public static final String NAME = "newsainton";

public abstract void fun();

}

// 一个类可以继承多个接口,但如果该类不是抽象类的话,则必须实现抽象类中的所有抽象方法

class Student implements Person

{

public void fun()

{

System.out.println("name = "+NAME);

}

}

public class Demo02

{

public static void main(String args[])

{

Student s = new Student();

s.fun();

}

}

//接口中包含了抽象类和抽象方法，因此代码也可以这样写

interface Person

{

//接口中包含了抽象类和抽象方法

//public static final String NAME = "newsainton";

public String NAME = "newsainton";

//public abstract void fun();

public void fun();

}

class Student implements Person

{

public void fun()

{

System.out.println("name = "+NAME);

}

}

public class Demo03

{

public static void main(String args[])

{

Student s = new Student();

s.fun();

}

}

一个接口可以使用extends关键字去继承一个或多个已有的接口,但在子类的实现时,也必须全部实现所有接口的抽象方法.

interface A

{

public void printA() ;

}

interface B

{

public void printB() ;

}

interface C extends A,B

{

public void printC() ;

}

class X implements C

{

// 如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法

public void printA()

{

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

}

public void printB()

{

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

}

public void printC()

{

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

}

}

public class Demo04

{

public static void main(String args[])

{

X x = new X() ;

x.printA() ;

x.printB() ;

x.printC() ;

}

}

3.2如果一个子类既要继承一个抽象类,又要实现一个接口,该怎么写呢?

我们采取的是: class 类名称 extends 抽象类 implements 接口 这样的语法格式.