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 ...