JAVA基础

final关键字的使用，抽象类与接口的概念 收藏 
final关键字的使用，抽象类与接口的概念 

l        -----------------------------------------------------Final 关键字-----------------------------------------------------

在java中可以使用final关键字来声明 类 变量 方法 

·final标记的类不能被继承

//final标识的类不能被继承 即不能有子类

final class A1 {

}

class B1 extends A1 {

}
 

 

·final标记的方法不能被子类覆写

//final标记的方法 不能被子类覆写

class A2 {

    public final void fun() {

    }

}

/*  class B2 extends A2 {

    //覆写A类中的fun方法

    public void fun() {

    }

}*/
 

 

·final声明的变量（成员变量和局部变量）即为常量 只能赋值一次

class A3 {

    final String NAME = "哈维";

    public void fun() {

    //  name = "戈多";

    }

}

//被final标记的变量最好用大写表示
 

Public ：所有人都可以访问 访问权限最大

Static ：静态 是所有对象公有的

Final ：常量 

Public static final 标记的为全局常量  public static final NAME = “”;(全局常量)

 

l        ----------------------------------------------------抽象类----------------------------------------------------------------

抽象类的概念：就是含有抽象方法的类 

抽象方法：就是一个只有声明而没有实现的方法(没有方法体的方法)

 

抽象类和普通类的区别

       ·比普通类的定义中多出了一个抽象方法 普通类的定义在抽象类中都实用

       ·抽象类在类的声明处要使用abstract 声明为抽象类 抽象方法也是

 

l        抽象类的定义：

1.      抽象类必须用 abstract关键字类修饰 abstract class A {}

2.      抽象类中必须有抽象方法 抽象方法也要用 abstract来修饰 public abstract void fun()

且抽象方法只有声明没有实现

          普通类：变量 常量 方法  抽象类：变量 常量 方法 抽象方法

 

l        抽象类的使用规则

abstract class A4 {

    //抽象类中不能含有 final声明

    //final String name;

    int age;

    //抽象方法 只需声明而不需要实现

    public abstract void fun1();

    public abstract void fun2();

    public void fun3() {

       System.out.println("父类的非抽象方法");

    }

}

    //B4 是一个普通类 一般而言抽象类必须要有子类去实现

class B4 extends A4 {

    //抽象类的子类(如果此类是普通类)则必须覆写抽象类的所有抽象方法

    public void fun1() {

       System.out.println("覆写了父类的抽象方法fun1");

    }

    public void fun2() {

       System.out.println("覆写了父类的抽象方法fun2");

    }

}

//子类是抽象类 则可以不必覆写父类中的全部抽象方法

abstract class C4 extends A4{   }

public class Demo04_AbstractClass {

    public static void main(String[] args) {

       //抽象类不能被实例化 

       //new A4();

       B4 b4 = new B4();

       b4.fun1();

       b4.fun2();

       b4.fun3();

    }

}
 

·抽象类中必须要有抽象方法，抽象方法只需声明 不需要去实现

 

·抽象类不能直接被实例化 因此必须要由子类去实现 如果子类是普通类 则必须覆写抽象类中全部的抽象方法 如果子类是抽象类 则可以不必覆写父类中的抽象方法

 

·抽象类不能被直接实例化，即不能直接通过new关键字来实例化抽象类

·抽象类也属于java的单继承

 

l        抽象类的思考

 

n        抽象类中能否有构造方法?

abstract class A5 {

    private String info;

    //抽象类中的构造方法

    public A5() {

       System.out.println("父类A5的无参构造被调用");

    }

    //抽象类中 构造方法的重载

    public A5(String info) {

       System.out.println("父类A5含参构造被调用");

    }

    //抽象方法

    public abstract void fun();

}

class B5 extends A5 {

    //子类中的构造方法

    public B5() {

       System.out.println("子类B5被实例化");

    }

    //子类覆写父类的抽象方法

    public void fun() {

       System.out.println("抽象父类中的fun方法被覆写");

    }

}

public class Demo05_AbstractClassContructor {

    public static void main(String[] args) {

       //子类在实例化时 会先调用父类的构造方法 因此抽象类必须有构造方法

       B5 b5 = new B5();

       b5.fun();

    }

}

//抽象类是由子类去实现的 类的实例化要调用类的构造方法 子类在实例化时要先调用父类的构造方法 因此 抽象类中一定有构造方法
 

 

n        抽象类能否由 final 来声明?

不能 final标记的类不能被继承 而抽象类必须由子类来实现 因此 抽象类不能使用final来标记

 

 

l        --------------------------------------------------接口（interface）-----------------------------------------------------

如果在抽象类中全部都是抽象方法 和 全局变量 那么该类则用接口来表示 

接口中的全局变量 public static final String NAME;

接口的访问权限永远是 public 

接口在程序中叫做实现 即接口是通过子类实现的

l        接口中包括

·常量   ·抽象方法

l        接口的定义

Interface 接口名 {常量 抽象方法}

l        接口的使用规则

·一个类可以实现多个接口 继承一个抽象方法  

Class 类名 extends 父类 implements 接口A，B {}

interface A6 {

    //常量 必须先赋值 String INFO;这是错误的

    //public static final String INFO = "接口";

    String INFO = "接口";

    //抽象方法

    //public abstract void fun1();

    public void fun1();

    //因为接口中本来就规定必须是常量和抽象方法 因此常量和抽象方法可以简化成上述的写法

}

interface B6 {

    double VERSION = 1.6;

    public void fun2();

}

 

abstract class C6 {

    public abstract void print();

}

//一个类可以实现多个接口 继承一个父类

class D6 extends C6 implements A6,B6  {

    //子类必须实现接口的全部抽象方法 (接口：实现;继承：覆写)

    public void fun1() {

       System.out.println("信息："+this.INFO);

       System.out.println("版本号："+this.VERSION);

    }

    public void fun2() {

       System.out.println("版本号："+this.VERSION);

    }

    //覆写父类中的方法

    public void print() {

       this.fun1();

       this.fun2();

    }

}

public class Demo06_Interface {

    public static void main(String[] args) {

       D6 d6 = new D6();

       d6.print();

    }

}

 
 

·一个新的接口可以使用 extends 关键字去继承多个已有的接口 实现接口的多继承

       Interface 接口A  extends 接口B，接口C ,接口D { }

//接口A7

interface A7 {

    public void funA();

}

//接口B7

interface B7 {

    public void funB();

}

//接口C7继承了接口 A7 B7 注意：接口可以多继承 而抽象类不能多继承 

interface C7 extends A7,B7 {

    public void funC();

}

//抽象类D7 实现了接口 C7

abstract class D7 implements C7 {

    //接口C7中的抽象方法fun7

    public abstract void funC();

}

//类 E7 继承了 抽象类D7 实现了接口C7

class E7 extends D7 implements C7 {

    //funC()同时存在于 D7和C7中 但E7值认方法名

    public void funC() {

       System.out.println("Hello C7");

    }

    public void funA() {

       System.out.println("Hello A7");

    }

    public void funB() {

       System.out.println("Hello B7");

    }

}

public class Demo07_InterfaceExtends {

    public static void main(String[] args) {

       E7 e7 = new E7();

       e7.funA();

       e7.funB();

       e7.funC();

    }

}
 

1.      普通类<----(继承 普通类之间是单继承关系 不建议去继承一个普通类)---普通类

2.      普通类<----(继承 抽象类必须由子类去实现,子类必须覆写抽象类中所有的抽象方法)-------抽象类

3.      普通类<----(可实现多接口 接口由子类去实现 子类必须实现接口中所有的抽象方法) ------接  口

4.      抽象类<----(继承 抽象类间是单继承关系 抽象类子类可以不用覆写父类中的抽像方法)---抽象类

5.      抽象类<----(可实现多接口 抽象内中可以有非抽象方法 因此可以实现接口中的抽象方法) ---接口

6.      接口<----(多继承或单继承 不能是实现关系 接口在继承时可以不去覆写父接口中的方法)---接口