面向对象基础八

 

Final关键字

在java中声明类、变量和方法时，可使用关键字final来修饰

1、 Final标记的类不能被继承

//标识此类不能被继承，即不能有子类

 final class A

 {

 }

 class B extends A

 {

 }

 

2、 Final标记的方法不能被子类重写

 

class A

{

       public final void fun()

       {}

}

 

class B extends A

{

       //覆写类A中的final 定义的fun方法

       public void fun()

       {}

}

3、 Final 标记的变量（成员变量或局部变量）即成常，只能赋值一次

class A

{

       public static final String name = "mldn";

       public final void fun()

       {

              name = "www. mldn .cn";   //无法为最终变量 name 指定值

       }

}

 

抽象类：就是一个包含一个抽象方法的类

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

 

抽象类与普通类之间的差别只在两处：

1、 比普通类的定义中多出一个抽象方法，变通类的所有定义在抽象类中都可以使用

2、 在类的声明处需要用abstract 声明为抽象类，抽象方法必须用abstract 来声明

普通类： 变量、常量、方法

抽象类本身不能被直接实例化

 

abstract class A

{

       public void fun2()

       {

              System.out.println("Hello World!!!");

       }

       public abstract void fun()

       {

       }

}

 

public class javaoo03

{

       public static void main(String []args)

       {

              new A(); // javaoo03.java:52: A 是抽象的；无法对其进行实例化 new A();

       }

}

 

抽象类的定义

1、 抽象类必须用abstract 关键字来修饰

如； abstract class 类名{}

2、 抽象方法也必须用abstract 来修饰

如：abstract public 返回类型方法名（）

 

//定义一个抽象类

抽象类必须有子类，子类如果不是抽象类的话，则必须覆写抽象类中的全部方法

抽象类也依然属于java的单继承模式

abstract class A

{

       public void fun2()

       {

              System.out.println("Hello World!!!");

       }

       public abstract void fun();

}

 

class B extends A

{

       //抽象类的子类要覆写类中的全部抽象方法

       public void fun()

       {

              System.out.println("欢迎大家学习www.mldn.cn");

       }

}

 

public class javaoo03

{

       public static void main(String []args)

       {

              B b = new B();

              b.fun();

              b.fun2();

       }

}

 

 

//欢迎大家学习www.mldn.cn

//Hello World!!!

 

抽象类必须有子类，子类如果不是抽象类的话，则必须覆写抽象类中的全部方法

抽象类也依然属于java中的单继承模式

 

 

抽象类可以有构造方法吗？

抽象类可以用final声明吗?

 

构造方法是对象实例化进使用

抽象类本身是可以包含抽象方法的

子类对象在实例化时依然先实例化父类中的属性，再实例化本类中的属性。子类对象的实例化过程。

abstract class A

{

       private String info;

       /**

       public A()

       {

              System.out.println("抽象类中的构造方法。");

       }

       */

       public A(String info)

       {

              this.info = info;

              System.out.println("抽象类中的构造方法。");

       }

       public void fun2()

       {

              System.out.println("info ----- " + this.info);

       }

       public abstract void fun();

}

 

class B extends A

{

       public B(String info)

       {

              super(info);

       }

       public void fun()

       {

              System.out.println("欢迎大家光临www.mldn.cn.");

       }

}

 

public class javaoo03

{

       public static void main(String []args)

       {

       }

}

 

Final 可以声明一个类，但是此类是一个不能有子类的父类，而抽象类本身又必须有子类。

final abstract class A

{

}

 

class B extends A

{

}

 

//javaoo03.java:153: 非法的修饰符组合：abstract 和 final

 

 

 

接口（interface）

接口：是抽象方法和常量的集合

接口定义：interface 接口名

                     {

                     数据类型变量名＝值；

                     返回值类型 方法名（[参数]）;

}

interface A //接口定义

{

       //定义常量

       //public static final String INFO = "HYJ";

       String INFO = "HYJ";

       //public abstract void say();

       public void say();

}

 

抽象类中包含抽象方法，如果在类中全部是抽象方法时，则用接口表示

接口中还包括全局常量： public static final

接口中的访问权限永远是: public

接口在程序中叫做实现，即一个接口必须通过子类实现

 

接口的使用规则

1、 一个类可以实现多个接口

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

 

interface A //接口定义

{

//定义常量

String INFO = "HYJ";

public void say();

}

 

class X implements A //接口实现

{

//子类要实现接口中全部的抽象方法

public void say()

{

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

}

}

 

public class javaoo03

{

public static void main(String []args)

{

        X x =new X();

        x.say();

}

}

 

//信息是：HYJ

 

 

 

interface A

{

//定义常量

String INFO = "HYJ";

//      public void say()

//      {

//      }

//接口方法不能带有主体；

public void say();

}

 

interface B

{

String MURL = "www.mldn.cn";

public void hello();

}

 

class X implements A,B

{

//子类要实现接口中全部的抽象方法

public void say()

{

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

        System.out.println("MURL是：" + MURL);

}

public void hello()

{

        System.out.println("B接口中的内容：" + MURL);

}

}

 

public class javaoo03

{

public static void main(String []args)

{

        X x = new X();

        x.say();

        x.hello();

}

}

信息是：HYJ

MURL是：www.mldn.cn

B接口中的内容：www.mldn.cn

 

一个新的接口用extends 关键字去继承一个己有的接口，实现接口的多继承

Interface 接口A extends 接口1、接口2{}

一个接口允许同时继承多个接口，但是一个类是不允许继承多个类

如果抽象方法同名，则在子类中只需要实现一次即可

interface A

{

String INFO = "HYJ";

public void say();

}

 

interface B

{

String MURL = "www.mldn.cn";

public void hello();

}

 

abstract class C

{

public abstract void fun();

}

 

class X extends C implements A , B

{

//子类要实现接口中全部的抽象方法

public void say()

{

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

        System.out.println("MURL是；" + MURL);

}

public void hello()

{

        System.out.println("B接口接口中的内容：" + MURL);

}

public void fun()

{

        say();

        hello();

}

}

 

public class javaoo03

{

public static void main(String []args)

{

        X x = new X();

        x.say();

        x.hello();

        x.fun();

}

}

 

信息是：HYJ

MURL是；www.mldn.cn

B接口接口中的内容：www.mldn.cn

信息是：HYJ

MURL是；www.mldn.cn

B接口接口中的内容：www.mldn.cn

 

 

interface A

{

public void printA();

}

 

interface B

{

public void printB();

}

 

interface C extends A,B

{

public void printC();

}

 

abstract class D implements C

{

public abstract void printC();

}

 

class X extends D implements C

{

public void printA()

{

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

}

public void printB()

{

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

}

public void printC()

{

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

}

}

 

Hello A ...

Hello B ...

Hello C ...