一、final关键字的使用
- final关键字在java中被称为完结器，表示最终的意思。
- final能声明类、方法、属性：
- 使用final声明的类不能被继承。
- 使用final声明的方法不能被重写。
- 使用final声明的变量变成常量，常量是不可以被修改的。
final String NAME = "Hello"; //name大写
二、抽象类
1、概述
- 抽象类概念：包含一个抽象方法的类就是抽象类。
- 抽象方法：声明而未被实现的方法，抽象方法必须使用
abstract关键字声明。
- 抽象类被子类继承，子类（如果不是抽象类）必须重写抽象类中德所有抽象方法。
- 定义格式：
abstract class className{ 属性 方法 抽象方法 }
- 抽象类不能直接实例化，要通过其子类进行实例化。
代码
abstract class Abs{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void tell() {
}
//抽象方法
public abstract void say();
public abstract void print();
}
class AbsDemo extends Abs{
public void say() {
System.out.println(getAge());
}
public void print() {
}
}
public class Demo20 {
public static void main(String[] args) {
AbsDemo a = new AbsDemo();
a.setAge(20);
a.say();
a.print();
a.setAge(20);
}
}
结果：
20
2、应用
代码
abstract class PersonN{
private int age;
private String name;
public PersonN(int age,String name){
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//抽象方法
public abstract void want();
}
class Stu extends PersonN{
private int score;
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Stu(int age, String name,int score) {
super(age, name);
// TODO Auto-generated constructor stub
this.score = score;
}
@Override
public void want() {
// TODO Auto-generated method stub
System.out.println("姓名："+getName()+" 年龄："+getAge()+" 成绩："+getScore());
}
}
class Work extends PersonN{
private int money;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public Work(int age, String name,int money) {
super(age, name);
// TODO Auto-generated constructor stub
this.money = money;
}
@Override
public void want() {
// TODO Auto-generated method stub
System.out.println("姓名："+getName()+" 年龄："+getAge()+" 工资："+getMoney());
}
}
public class Demo25 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Stu tu = new Stu(10, "小明", 100);
tu.want();
Work w = new Work(35, "大明", 1000);
w.want();
}
}
结果：
姓名：小明 年龄：10 成绩：100
姓名：大明 年龄：35 工资：1000
三、接口
1、实现
- 接口是Java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
- 接口的格式：
interface interfaceName{ 全局常量 抽象方法 }
- 接口的实现也必须通过子类，使用关键字
implements，而且接口是可以多实现的。
- 一个子类可以同时继承抽象类和实现接口。
- 一个接口不能继承一个抽象类，但是却可以通过
extends关键字同时继承多个接口，实现接口的多继承。
代码
interface Inter1{
public static final int AGE = 100;//全局常量
public abstract void tell();
}
interface Inter2{
public abstract void say();
}
abstract class Abs1{
public abstract void print();
}
class Ai extends Abs1 implements Inter1,Inter2{
public void tell() {
}
public void say() {
}
public void print() {
}
}
interface Inter3 extends Inter1,Inter2{
}
public class Demo21 {
public static void main(String[] args) {
Ai a = new Ai();
a.tell();
System.out.println(Inter1.AGE);
a.say();
a.print();
}
}
2、使用
代码
interface USB{
//抽象方法
void start();
void stop();
}
class C{
public static void work(USB u) {
u.start();
System.out.println("工作中");
u.stop();
}
}
class USBDisk implements USB{
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("U盘开始工作");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("U盘停止工作");
}
}
class Printer implements USB{
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("打印机开始工作");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("打印机停止工作");
}
}
public class Demo26 {
public static void main(String[] args) {
// TODO Auto-generated method stub
C.work(new USBDisk());
C.work(new Printer());
}
}
结果：
U盘开始工作
工作中
U盘停止工作
打印机开始工作
工作中
打印机停止工作
