一:关键字final?
- final是一个修饰符,可以修饰方法,类,变量
- final是一个修饰的类不可以被继承(继承的弊端:打破了封装性)
- final是一个修饰符的方法不可以被覆盖
- final修饰的变量是常量,只能被赋值一次
- final会显示初始化,如果final int x系统会报错,要赋值
-public static全局变量
-static不需要对象,用类名就可以调用访问
-public static final 全局常量
- 只要是固定值(常量)就要用final定义,定义的标准
-取一个有意义的名称
-写法哟啊规范,常量所有字母都是大写,若多个字母则需要下划线连接
/*final*/ class Fu{
void method(){
}
}
class Zi extends Fu{
void method(){
final double MY_PI=3.14;
static final int x=7;
//inal int x=9;
//x=8;
System.out.println(x);
}
}
class FinalDemo{
public static void main(String[] args){
Zi z=new Zi();
z.method();
}
}
二:抽象类
1,抽象那就是笼统,模糊,看不清,朦胧等意思
2,抽象类的特点
- 方法只有声明没有实现时,叫做抽象方法。该方法要用abstract修饰,
- 抽象方法必须定义在抽象类中,所以该类也必须被abstract所修饰
- 抽象类没有实例化(用类创建对象的一个过程 Dog d=new Dog();)因为调用抽象方法没有意义
- 该抽象类中必须其子类覆盖所有的抽象方法后,其子类才有实例化,否则该子类也是抽象类
abstract class DemoA{
final abstract void show();
}
class DemoB extends DemoA{
void show(){
System.out.println("show b");
}
}
class DemoC extends DemoA{
void show(){
System.out.println("show c");
}
}
class AbstractDemo{
public static void main(String[] args){
}
}
三:关于抽象类的小问题
- 抽象类中是否有构造函数?
-答:有,用于给子类对象进行初始化
-
抽象类可以不定义抽象方法吗?
-答:可以,很少见,就是为了不让类创建对象
class demo{
void show1(){}
void show2(){}
} -
抽象类和一般类的区别?
-相同点:都在内部定义了成员,且都是为了描述事物
-不同点:1)一般类有足够的信息描述事物,抽象类描述事物可能信息不足
2)一般类不能定义抽象方法,只能定义非抽象方法。但是抽象类都可以定义
3)一般类可以被实例化,抽象类不可以被实例化
- 抽象类与哪些关键字不能共存?
-private
-static
-final
- 抽象类一定是父类吗?
-答:是的,因为子类覆盖其方法后子类才可以进行实例化
四:抽象类的实例
/*
雇员示例:
需求:公司中程序员有姓名,工号,薪水,工作内容
对项目经理除了有姓名,工号,薪水,还有奖金,工作内容
对给出需求进行数据建模
分析:在这个问题领域中,先找出涉及的对象
通过名词提炼法
程序员
属性:姓名,工号,薪水
行为:工作
经理:
属性:姓名,工号,薪水,奖金
行为:工作
程序员和经理不存在直接的继承关系
但是程序员和经理却具有共性的内容
可以进行抽取,因为都是公司的员工
可以将程序员和经理进行抽取,建立体系
*/
class Employee{
private String name;
private String id;
private double pay;
Employee(String name ,String id ,double pay){
this.name=name;
this.id=id;
this.pay=pay;
}
public abstract void work();
}
class Programmer extends Employee{
Programmer(String name,String id,double pay){
super(name ,id,pay);
public abstract void work(){
System.out.println("programmer work code ");
}
}
}
class Manager extends Employee{
Manager(String name,String id,double pay,int bonus){
super(name,id ,pay,bonus);
this.bonus=bonus;
}
public abstract void work(){
System.out.println("manager work");
}
}
class AbstractDemo2{
public static void main(String[] args){
}
}
/*
对于学生与工人的案例同样适用
*/
class Person{
private String name;
private int age;
Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return name ;
}
public void setName(String name){
this.name=name;
}
}
class Student extends Person{
Student(String name,int age){
super(name,age);
}
}
public void student(){
System.out.println("student studay");
}
class Worker extends Person{
Worker(String name,int age){
super(name,age);
}
}
public void work(){
System.out.println("work jobs");
}
五:接口
-
当一个抽象类中的方法都是抽象时,可以将该抽象类用另一种方式去定义和表示------那就是接口(interface)
-
定义接口使用的关键字不是class,而是interface
-
接口中常见的成员(有固定修饰符的成员)—接口成员的权限都是最大的
-public static final全局常量
-public abstract抽象方法 -
接口不可以实例化(抽象类也不可以实例化)只有实现接口子类覆盖接口所有的方法后,该子类才可以叫实例化,否则这个类就是抽象类
-
在java中不直接支持多继承,因为会出现调用的不确定性
所以java将多继承机制进行改良,在java中变成了多实现 -
一个类可以实现多个接口
-
一个类在继承另一个类的同时,还可以实现多个接口
-
接口的出现避免了单继承的局限性
-
类与类之间是继承关系,类与接口之间是实现关系,接口与接口之间是继承(而且接口可以多继承)
interface A{
public void showA();
}
interface B{
public void showB();
}
class Test implements A,B{
public void show(){
}
}
interface Demo{
public static final int NUM=4;
public abstract void show1();
public abstract void show2();
}
class DemoImpl implements Demo{
public void show1(){}
public void show2(){}
}
class Q{
public void method(){}
}
class Test2 extends Q implements A,B{
}
interface CC{
void show();
}
inteface MM{
void method();
}
interface QQ extends CC,MM{//jiekou yu jiekou zhijianshijichengguanxi
void function();
}
class WW implements QQ{
//fugai dange fangfa
public void show(){}
public void method(){}
public void function(){}
}
class InterFaceDemo{
public static void main(String[] args){
Test t=new Test();
t.show();
//DemoImpl d=new DemoImpl();
//d.show();
//System.out.println(d.NUM);
//System.out.println(DemoImpl.NUM);
//System.out.println(Demo.NUM);
}
}
六:接口的特点
- 接口对外暴露规则
- 接口是程序的功能扩展
- 接口出现降低耦合性
- 接口用来实现多实现
七:接口与抽象类的区别
相同点:都是不断向上抽取而来
不同点:
1,抽象类需要被继承,而且只能单继承
接口需要被实现,而且可以多实现
2,抽象类中可以定义抽象方法和非抽象方法,子类继承后,可以直接使用非抽象方法
接口只能定义抽象方法,必须由子类去实现
3,抽象类的基础,是is a关系,在定义该体系的基本共性内容
接口实现是 like a 关系,在定义体系额外功能
abstract class Dog{
abstract void jiao();
}
abstract class DaoMang{
abstract void DaoMang();
}
class DaoMangDog extends Dog{
public void jiao(){}
public void work(){
System.out.println("daomang");
}
}
class InterfaceDemo2{
public static void main(String [] args){
}
}
八:接口的实现
//笔记本电脑的使用、
//为了扩展笔记本的功能,但日后出现的设备都符合这个规则就可以
interface USB{
public void open();
public void close();
}
class InterfaceDemo4{
public static void main(String[] args){
//useUSB(null);
useUSB(new UPan());//功能扩展了
useUSB(new UsbMouse());
}
public static void useUSB(USB u){//接口类型引用,用于接收接口的子类对象
u.open();
u.close();
}
}
//一年后,实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
public void open(){
System.out.println("upan open");
}
public void close(){
System.out.println("upan close");
}
}
class UsbMouse implements USB{
public void open(){
System.out.println("UsbMouse open");
}
public void close(){
System.out.println("UsbMouse close");
}
}