JavaSE学习(6) 面向对象类和对象（5）抽象类、接口、final

抽象类、接口、final

抽象类：

父类方法的不确定性时，可以用abstract关键字来修饰该方法（抽象方法），用abstract来修饰该类（抽象类）

1、用abstract关键字来修饰一个类时，这个类就是抽象类

2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法

注意事项：

1）抽象类不能被实例化

2）抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法。

3）一旦类包含了abstract方法，则这个类必须声明为abstract。

4）抽象方法不能有主体，如：abstract void a（）｛｝是错误的

package com.test2;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub

}

}
//这就是一个抽象类
abstract class Animal{
String name;
int age;
abstract public void cry();

}
//当一个继承的父类是抽象类的话
//需要我们把抽象类中 的所有抽象方法全部实现
class Cat extends Animal{

@Override//实现父类的cry
public void cry() {
// TODO Auto-generated method stub
//do something...
System.out.println("喵喵叫...");
}

}

接口：

接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，语法格式：

class 类名 implements 接口｛

方法；

变量；

｝

小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低耦合的设计思想。

注意事项：

1）接口不能被实例化

2）接口中的所有方法都不能有主体，与抽象类区别（抽象类里可以有实现的方法！）

3）一个类可以实现多个接口

4）接口中可以有变量[但变量不能用private和protected修饰]

接口中的变量，本质上都是static的，而且是final，不管你加不加static修饰

在java开发中，经常把常用的变量定义在接口中，作为全局变量使用。

访问形式：接口名.变量名

5）一个接口不能继承其他的类，但是可以继承别的接口

/*
* 功能：接口的讲解
* */
package com.test3;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
//创建一个计算机
Computer computer=new Computer();
//创建Camera
Camera camera=new Camera();
//
Phone phone=new Phone();
computer.useUsb(camera);
computer.useUsb(phone);
}

}
//USB接口
interface Usb{
int a=1;
//声明两个方法
//开始工作
public void start();
//停止工作
public void stop();
}
//编写照相机类，并实现Usb接口
//一个原则：当一个类实现了一个接口，就要求该类把这个接口的所有方法，都实现！
class Camera implements Usb,Kkk{
public void start(){
System.out.println("我是相机，开始工作");
}
public void stop(){
System.out.println("我是相机，停止工作");
}

}
//编写手机
class Phone implements Usb{
public void start(){
System.out.println("我是手机，开始工作");
}
public void stop(){
System.out.println("我是手机，停止工作");
}

}
//计算机
class Computer{
//开始使用usb接口
public void useUsb(Usb usb){
usb.start();
usb.stop();
}
}
interface Aaa{
//public void Eee();
}
//一个接口
interface Kkk extends Aaa{
//public void cry();
}
//接口继承别的接口
class Base{

}

java实现接口vs继承类

java的继承是单继承，一个类最多只能有一个父类，这种单继承机制可保证类的纯洁性，比C++中的多继承机制简洁。但是不可否认，对子类功能的扩展有一定影响。

1）实现接口可以看成是对继承的一种补充

继承是层级式的，不灵活

2）实现接口可在不打破继承关系的前提下，对某个类功能扩展，非常灵活。

package com.test4;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub

}

}
interface Fish{
public void swimming();

}
interface Bird{
public void fly();
}
class Monkey{
int name;
//跳
public void jump(){
System.out.println("猴子会跳！");
}
}
class LittleMonkey extends Monkey implements Fish,Bird{

@Override
public void swimming() {
// TODO Auto-generated method stub

}

@Override
public void fly() {
// TODO Auto-generated method stub

}

}
final：

可以修饰变量或者方法，以下情况：

1）当不希望父类的某个方法被子类覆盖（override）时，可以用final关键字修饰。

2）当不希望类的某个变量的值被修改，可以用final修饰。如果一个变量是final，必须赋初值。final float rate;rate=3.14;就是错误的！

3）当不希望类被继承时，可以用final修饰。

注意事项：

1）final修饰的变量又叫常量，一般用xx_xx_xx来命名

2）final修饰的变量在定义时，必须赋值，并且以后不能再赋值。

使用的场景：

1）出于安全的考虑，类的某个方法不允许修改

2）类不会被其他的类继承

3）某些变量是固定不变的，比如圆周率3.1415

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
Aaa aaa=new Aaa();
aaa.show();
}

}
//final修饰类则表示该类不能被继承
//final class Aaa{
class Aaa{
int a;//如果不给初值，a=？ a=0
//圆周率
final float rate=3.1415926f;
//给方法用final修饰，则表示不可以被修改，不可被覆盖
final public void sendMes(){
System.out.println("发送消息");
}
public void show(){
System.out.println("a="+a);
}
}
class Bbb extends Aaa{
public Bbb(){
a++;
// rate+=1;
}
/*public void sendMes(){
System.out.println("发送消息");
}*/
}