java基础学习笔记3

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();

}

Simulator.java

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 的)
5.10.1 接口的声明与使用
1，接口的声明

接口通过使用关键字interface来声明，格式如下：

interface 接口的名字

2.接口体

接口体包含常量定义和方法定义两个部分。接口体中只有抽象方法，没有普通方法，而且接口体中所有的常量的访问权限一定是public(允许省略public ,final修饰符)，所有抽象方法的访问权限一定都是public (允许省略public,abstract修饰符)，例如：
intreface Printable{
public final int MAX=100;
public abstract void add();
public abstract float sum(float x,float y);
}

3.接口的使用
一个类通过使用关键字implements声明自己实现一个或多个接口，如果实现多个接口，用逗号隔开接口名，如A类实现Printable和Addable接口：
class A implements Printable,Addable
再如Animal的子类Dog实现Eatable和Sleepable接口：

class Dog extends Eatable,Sleepable