Java SE面向对象部分-15.面向对象高级(03)

Java SE面向对象部分-15.面向对象高级（03）

上季内容回顾：

1、super与this关键字 2、方法的重载与覆写 本季主要知识点： 1、final关键字

2、简单了解一下抽象类与接口(是JAVA中最重要的部分) final关键字

终结器 —— final

1、被final标记的类不能被继承 final class A { };

class B extends A { };

验证一下：

2、被final标记的方法不能被子类覆写 final class A {

public final void print(){} };

class B extends A {

public void print(){} };

3、被final标记的变量就成为常量，如果成为常量，则以后不能修改 class A {

final String NAME = \; public final void print() {

NAME = \; } };

之前在声明变量的时候是第一个单词的首字母小写，之后每个单词的首字母大写。如果使用final声明常量，则所有单词的字母都要大写。 重点：全局常量：

· static：是所有对象共享的 · final：是一个常量

· public：表示可以让外部看见

public static final String FLAG = \全局常量 抽象类

抽象类：包含一个抽象方法的类就称为抽象类。 抽象方法：只声明而未实现的方法称为抽象方法。

方法没有方法体（方法体：“{}”），则称为是一个抽象方法。 除了抽象方法之外其他的定义如同普通类一样。 抽象类 = 普通类的功能 + 抽象方法

abstract class A {

public static final String FLAG = \; public void print() {

//有方法体，所以是一个普通方法

System.out.println(\World~~~\); }

//此处定义了一个抽象方法 public abstract void fun(); };

public class Demo04 {

public static void main(String args[]) {

A a = new A(); } };

如果要使用一个抽象类，不能直接实例化，抽象类是必须有子类的。

抽象类必须被继承，被继承的子类如果不是一个抽象类的话，则肯定要覆写全部的抽象方法。 abstract class A {

public static final String FLAG = \; public void print() {

//有方法体，所以是一个普通方法

System.out.println(\World~~~\); }

//此处定义了一个抽象方法 public abstract void fun(); };

//子类中覆写了抽象类中的全部抽象方法 class B extends A {

public void fun() {

//super.FLAG也可以写成FLAG,因为FLAG已经是全局常量了哈~~~ System.out.println(\+super.FLAG);

} };

public class Demo04 {

public static void main(String args[]) {

B b = new B(); b.fun(); b.print(); } };

验证效果，证明抽象类必须这样写哈~~~

抽象类的定义

抽象类的使用规则

抽象类的思考

abstract class Person {

//Person类应该有姓名和年龄 private String name; private int age;

public Person(String name,int age) {

this.name = name; this.age = age; }

public void setName(String name) {

this.name = name; }

public void setAge(int age) {

this.age = age; }

public String getName() {

return this.name; }

public int getAge() {

return this.age; }

//定义一个输出方法，但是此方法为抽象方法 public abstract String getInfo(); };

我们测试一下，发现编译正常，说明抽象类可以有构造方法哈~

我们继续哈~

abstract class Person {

//Person类应该有姓名和年龄 private String name; private int age; public Person(){}

//如果已经不是无参的，则必须在子类中明确调用无参构造 public Person(String name,int age) {

this.name = name; this.age = age; }

public void setName(String name) {

this.name = name; }

public void setAge(int age) {

this.age = age; }

public String getName() {

return this.name; }

public int getAge() {

return this.age; }

//定义一个输出方法，但是此方法为抽象方法 public abstract String getInfo(); };

class Student extends Person {

public Student(String name,int age) {

//调用Person类中有两个参数的构造方法 super(name,age); }

//覆写父类的抽象方法 public String getInfo() {

return \姓名：\+super.getName()+\，年龄：\+super.getAge(); } };

public class Demo05 {

public static void main(String args[]) {

Student s = new Student(\王乾\,27); System.out.println(s.getInfo()); } }

抽象类中允许有构造方法，但是此构造方法并不是直接实例化抽象类自己的对象使的，如果在抽象类中没有明确的无参构造方法，即：存在有参构造，则必须在子类明确的使用super指明要调用父类中的那个构造方法。 注意：

如果一个抽象类中没有任何一个抽象方法，则也是不能直接实例化的。 abstract class A {

public void print(){} };

public class Demo06 {

public static void main(String args[]) {

new A(); } };

final可以声明一个类，但是此类是绝对不能有子类的。 而抽象类又必须被子类继承。 ==>矛盾的 final abstract class A { };

验证下效果，我们发现抽象类是不能使用final声明的。

如果假设一个类就是抽象方法和常量的集合，那么此时往往都不再使用抽象类声明了，而使用接口声明。

接口（interface）

interface A {

//接口中包含了抽象方法和全局常量

public static String NAME=\; public abstract void print(); };

接口的使用规则（1）

一个子类继承接口实际上称为实现了接口。 interface A {

//接口中包含了抽象方法和全局常量

public static String NAME=\; public abstract void print(); };

class B implements A {

public void print() {

System.out.println(\+NAME);

如果实现接口的子类不是抽象类的话，则子类必须覆写接口中的全部抽象方法。

} };

public class Demo09 {

public static void main(String args[]) {

B b = new B(); b.print(); } };

接口使用的事项：

1、抽象类使的是extends关键字，表示一个类只能继承一个父类，但是接口不同，一个类可以同时实现多个接口，但是此时子类就必须同时覆写好多个接口中的抽象方法。 interface A {

//接口中包含了抽象方法和全局常量

public static String NAME=\; public abstract void print(); };

interface X {

public abstract void fun(); };

class B implements A,X {

public void print() {

System.out.println(\+NAME); }

public void fun() {

this.print(); } };

public class Demo10 {

public static void main(String args[]) {

B b = new B(); b.fun(); } };

抽象类拥有单继承的局限，而接口没有此限制，即：一个子类可以同时实现多个接口。 2、既然在定义中已经明确的说明了接口是抽象方法和全局常量的集合，则在定义接口的时候就可以简单定义。 interface A {

//接口中包含了抽象方法和全局常量

//public static String NAME=\ String NAME=\; //public abstract void print(); void print(); };

class B implements A {

public void print() {

System.out.println(\+NAME); } };

public class Demo11 {

public static void main(String args[]) {

B b = new B(); b.print(); } };

简化后实现的效果一样哈~

一般习惯在简化时还在前面加上public,呵呵~~~

interface A {

//接口中包含了抽象方法和全局常量

//public static String NAME=\ public String NAME=\; //public abstract void print(); public void print(); };

class B implements A {

public void print() {

System.out.println(\+NAME); } };

public class Demo12 {

public static void main(String args[]) {

B b = new B(); b.print(); } };

接口的使用规则（2）

interface A {

public void printA(); }

interface B {

public void printB(); }

interface C extends A,B {

public void printC(); }

class X implements C {

//如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法 public void printA() {

System.out.println(\接口 ===> Hello World~~~\); }

public void printB() {

System.out.println(\接口 ===> Hello World~~~\); }

public void printC() {

System.out.println(\接口 ===> Hello World~~~\); } }

public class Demo13 {

public static void main(String args[]) {

X x = new X(); x.printA(); x.printB(); x.printC(); } }

如果一个子类即要实现一个接口又要继承一个抽象类呢？ 则此时按以下格式编写：

class 类名称 extends 抽象类 implements 接口 interface X {

public void printX(); }

interface Y {

public void printY(); }

//一个抽象类也是可以实现接口的 abstract class Z implements Y {

public abstract void printZ(); }

//D类同时继承Z类和实现X接口 class D extends Z implements X {

public void printX() {

System.out.println(\===>Hello~~~\); }

public void printY() {

System.out.println(\===>Hello~~~\); }

public void printZ() {

System.out.println(\===>Hello~~~\); } }

public class Demo14 {

public static void main(String args[]) {

D d = new D(); d.printX(); d.printY(); d.printZ(); } }

总结

1、final关键字

2、抽象类与接口的定义及基本使用

ps:谨以此文庆祝本blog突破20W访问量，希望在2009年获得新的突破，得到技能的提升，下季我们将一起来学习多态哈~~~

#########################################################################

本文来源：https://www.bwwdw.com/article/ozi6.html