5.6final关键字(最终)
final关键字可以修饰类,成员变量和方法中的局部变量。
5.6.1final类
可以使用final将类声明为final类,final不能被继承,即不能有子类,例如:
final class A{
......
}
A就是一个final类,将不允许任何类声明成A的子类。
final关键字小结:
final作为一个修饰符:
1,可以修饰类,函数和变量;
2,被final修饰的类不可以被继承,为了避免被继承,被子类复写功能就需要将类final。
3,被final的方法不可以被复写;
4,被final 的变量是一个常量。
5.6.2final方法
如果用final修饰父类中的一个方法,那么这个方法不允许子类重写。也就是说,不允许子类隐藏可以继承的final方法(不允许做任何篡改)
5.6.3常量
如果成员变量或局部变量被修饰成final,就是常量。常量在声明时没有默认值,所以在声明常量是必须指定该常量的值,而且不能发生变化。
当在描述事物时,一些数据的出现值是固定的,为了增强阅读性,都给这些值取个名字,方便阅读,而这些值不需要改变,所以加上final修饰。
例5.8
Example5_8.java
class A
{//final double PI //非法,因为没有给常量指定值
final double PI=3.1415926; //Pi是常量
public double getArea(final double r)
{
//r=89; //非法,因为不允许改变r的值
return PI*r*r;
}
public final void speak(){
System.out.println("您好,Hao's everything here?");
}
}
class B extends A
{/*非法,不能重写speak方法
public voidspeak(){
System.out.println("您好,Hao's everything here?")
}
*/}
public class Example5_8
{public static void main(String args[]) {
B b=new B();
System.out.println("面积"+b.getArea(100));
b.speak();//调用继承方法
}
}
</pre><pre class="java" name="code"><strong><span style="font-size:24px;">5.7对象的上转型对象</span></strong>
假设A类是B类的父类,当用子类创建一个对象,并把 这个对象的引用放到父类的对象中,例如:
A a;
a=new B();
或
A a;
B b=new B();
a=b;
这时,称对象a 是对象b的上转型对象。
上转型对象具有以下特点:
(1)上转型对象不能操作子类新增的成员变量(失掉了这部分属性),不能调用子类新增的方法(失掉了一些功能)
(2)上转型变量可以访问子类继承或者隐藏的成员变量,也可以调用子类继承的方法或者子类的重写方法。上转型对象调用子类继承的方法或者子类的重写方法,其作用等价于用子类对象去调用这些方法。因此,如果子类重写了父类的某个方法,当对象的上转型对象调用这个方法时,一定是调用了子类重写的方法。
对象的上转型对象还没懂,等老师讲解
待续.........
5.8继承与多态
多态的体现:当一个类有很多子类,并且这些子类都重写了父类中的某个方法时,那么把子类创建的对象的引用放到一个父类的对象中,就得到了 该对象的一个上转型对象。这个上转型对象在调用这个方法时可能具有多种形态,因为不同的子类在重写父类的方法时可能产生不同的行为。
多态性是指父类的某个方法被其子类重写时,可以各自产生自己的功能行为。
例5.10
Example5_10
<strong>class 动物
{
void cry(){
}
}
class 狗 extends 动物
{void cry(){
System.out.println("这是狗的叫声:汪汪");
}
}
class 猫 extends 动物
{
void cry(){
System.out.println("这是猫的叫声:喵喵");
}
}
public class Example5_10
{public static void main(String args[]){
动物 animal=new 狗(); //animal是狗的上转型对象
animal.cry();
animal=new 猫();//animal是猫的上转型对象
animal.cry();
}
}</strong>
5.9abstract类(抽象类)和方法
用关键字abstract修饰的类称为abstract类(抽象类)例如:
abstract class A{
... ...
}
用关键字abstract修饰的方法称为abstract方法(抽象方法),对于abstract方法,只允许声明,不允许实现,而且不允许使用final和abstract同时修饰一个方法。(原因:如果一个非抽象类是某个抽象类的子类,那么它必须重写父类的抽象方法)例如:
abstract int min(int x,int y);
5.9.1 abstract类的特点
(1)在abstract类中可以有abstract方法。和普通类相比,abstract类可以有abstract方法(抽象方法),也可以有非abstract方法。
下面类A中的min()方法是abstract方法,max()是普通方法:
abstract class A{
abstract int min(int x,int y);
int max(int x,int y){
return int x>y?x:y;
}
}
(2)abstract类不能用new 创建对象。
注:
1,abstract也可以没有abstract方法
2,如果一个abstract类是abstract类的子类,它可以重写父类的abstract方法,也可以继承这个abstract方法。
例5.11
Example5_11.java
<span style="font-size:18px;">abstract class A
{abstract int sum(int a,int y);
int sub(int x,int y){
return x-y;
}
}class B extends A
{int sum(int x,int y){ //子类必须重写父类的sum方法
return x+y;
}
}
public class Example5_11
{public static void main(String args[]){
B b=new B();
int sum=b.sum(30,20);//调用重写的方法
int sub=b.sub(30,20);//调用继承的方法
System.out.println("sum="+sum);
System.out.println("sub="+sub);
}
}</span>
抽象类只关心操作,不关心方法体。抽象类可以让程序设计者忽略具体的细节,以便更好的设计程序。例5.12
Example5_12.java
abstract class 机动车
{abstract void 启动();
abstract void 加速();
abstract void 刹车();
}
class 手动挡轿车 extends 机动车
{void 启动(){
System.out.println("踏下离合器,换到一档");
System.out.println("然后慢慢抬起离合器");
}
void 加速(){
System.out.println("踩油门");
}
void 刹车(){
System.out.println("踏下离合器,踏下刹车板");
System.out.println("然后将档位换到一档");
}
}
class 自动挡轿车 extends 机动车
{void 启动(){
System.out.println("使用前进挡");
System.out.println("然后轻轻踩油门");
}
void 加速(){
System.out.println("踩油门");
}
void 刹车(){
System.out.println("踏下刹车板");
}
}
public class Example5_12
{public static void main(String args[]){
机动车 car=new 手动挡轿车();
System.out.println("手动挡轿车的操作:");
car.启动();
car.加速();
car.刹车();
car=new 自动挡轿车();
System.out.println("自动挡轿车的操作:");
car.启动();
car.加速();
car.刹车();
}
}
</pre><pre class="java" name="code"><strong><span style="font-size:18px;">5.9.2 abstract类与多态</span></strong>
<strong><span style="font-size:18px;">例5.13</span></strong>
<strong><span style="font-size:18px;">Animal.java</span></strong><pre class="java" name="code">public abstract class Animal
{
public abstract void cry();
public abstract String getAnimalName();
}
public class Simulator
{public void playSound(Animal animal){
System.out.println("现在播放"+animal.getAnimalName()+"类的声音");
animal.cry();
}
}
Dog.java
public class Dog extends Animal
{
public void cry(){
System.out.println("汪汪");
}
public String getAnimalName(){
return "狗";
}
}
Cat.java
public class Cat extends Animal
{
public void cry(){
System.out.println("喵喵");
}
public String getAnimalName(){
return "猫";
}
}
Example5_13.java
<pre class="java" name="code">public class Example5_13
{public static void main(String args[]){
Simulator simulator=new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
}
}
5.10 接口(接口中的成员都是public 的)
1,接口的声明
接口通过使用关键字interface来声明,格式如下:
interface 接口的名字
2.接口体
再如Animal的子类Dog实现Eatable和Sleepable接口:
class Dog extends Eatable,Sleepable