java学习笔记<一> 继承与接口

5.1 子类与父类

语法  class 子类名 extends 父类名｛

            ......

         ｝

如果一个类的声明没有使用extends关键字，这个类被系统默认为Object的子类。

在java中所有的类都直接或间接的继承java.lang.Object类。Object类是所有类的父类，java类层中的最高层类。当创建一个类时，总是在继承，除非已经

指定了要从其他类中继承，否则他就是继承于Object类。Object中主要包括clone（）、finalize（）、equals（）、toString（）等方法。

toString()方法的功能是将一个对象返回为字符串形式，在实际应用中通常会重写这个方法，为对象提供一个特定的输出模式，当这个类转换为字符串或与字符串连接时将会自动调用重写的toString（）方法。

equals()方法比较的是两个对象的实际内容，“＝＝”比较的是两个对象的引用是否相同。

5.2 子类的继承性

若子类与父类在同一个包中，子类中继承了父类中不是private的成员变量以及方法，继承的成员变量和方法的访问权限不改变。

若子类与父类不在同一个包中，子类继承了父类的public、protected方法以及成员变量，子类不继承父类中的友好成员变量及方法。

（不被private、public、protected修饰的成员变量以及方法成为友好成员变量、友好方法。）

关于protected的进一步说明：

        如果用D类在D类本身创建了一个对象，那么该对象总是可以通过“."运算符，访问继承的或自己定义的protected变量或方法

如果在另外一个类中用D类创建了一个对象，该对象访问protected变量或方法的权限如下：

1、若其他类与D类在同一个包下，则新建的对象可以访问这些protected成员变量以及方法。

2、如果D中protected变量或方法是从父类中继承的，那么这个其他类和这个父类在同一个包中时，新建的对象才可以访问继承的protected变量及方法。

5.3 成员变量的隐藏和方法的重写

  一、成员变量的隐藏

只要子类中声明的成员变量和父类的成员变量同名，子类就隐藏了继承的成员变量。但子类可以通过调用父类继承的方法操作隐藏的成员变量。

  二、方法重写

方法重写是指在子类中定义一个方法，这个方法的类型和父类的一样。或者是父类方法的类型的子类型，并且这个方法的名字、参数个数、参数类型与父类的方法完全相同

重写父类方法时，不可以降低方法的访问权限，子类继承父类的访问修饰符要比父类的更大，假如父类是protected修饰的，其子类只能是protected或者public，绝对不能是friendly或者private，当然使用private就不是继承了。还要注意的是，继承当中子类抛出的异常必须是父类抛出的异常的子异常，或者子类抛出的异常要比父类抛出的异常要少。

class A{

protected float f(float x,float y){

return x-y;

}

}

class B extends A{

float f(float x,float y){  //非法，降低了访问权限

return x+y;

}

}

class C extends A{

public float f(float x,float y){ //合法，提高了访问权限

return x*y;

}

}

5.4 super 关键字

  一、使用super关键字调用父类的构造方法

子类不继承父类的构造方法，若想在子类中使用父类的构造方法

1、必须在子类的构造方法中使用  2、必须使用super 关键字来表示 3、super必须是子类的构造方法中第一条语句

public class Student{

int number;

String name;

Student(){

}

Student(int number,String name){

this.number=number;

this.name=name;

}

public int getNumber(){

return number;

}

public String getName(){

return name;

}

}

public class UniverStudent extends Student{

boolean isMarriage;

UniverStudent(int number,String name,boolean b){

super(number,name);               //调用父类的构造方法，执行Student（number，name）

}

public boolean getIsMarriage(){

return isMarriage;

}

} 

//省略主类......

若在子类的构造方法中没有明显的写出super关键字来调用父类的某个构造函数，那么有

super（）;

即调用父类的不带参数的构造方法。

  二、使用super操作被隐藏的成员变量和方法

如果想在子类中使用被隐藏的成员变量或者方法，使用关键字super、super.x、super.paly()即可。

public class sum{

int n;

public double f(){

double sum=0;

for(int i=0;i<=n;i++)

{

sum=sum+i;

}

}

}

public class Average extends sum{

double n;

public double f(){

double c;

super.n=(int) n;

c=super.f();

return c+n;

}

}

//省略主类.....

5.5 final关键字

  一、final类

可以使用final将类声明为final类。final类不可不继承

final class A{

........

}

  二、final方法

如果使用final修饰父类中的一个方法，那么这个方法不允许子类重写

  三、常量

如果成员变量、局部变量被修饰为final，就是常量

5.6 对象上转型对象

假设A类是B类的父类，当用子类创建一个对象，并将这个对象的引用放到父类的对象中：

A a;

a=new B();

称对象a是对象b的上转型对象（“老虎是哺乳动物”）。

对象的上转型对象的实体是子类负责创建的，但上转型对象会失去一些原对象的属性和功能。上转型对象具有如下特点：

（1）上转型对象不能调用子类新增的方法，不能操作子类新增的成员变量。

（2）上转型对象可以访问子类继承或者隐藏的成员变量，也可以调用子类继承的方法或者子类重写方法。

 

5.7abstract类与方法

使用关键字abstract修饰的类叫做abstract类（抽象类）

abstract class A{

......

}

使用关键字abstract修饰的方法称为abstract方法，对于abstract方法只允许声明不允许实现。

不允许final与abstract同时修饰同一个方法。

abstract int min( int x ,int y);

  一、abstract类的特点

（1）在abstract类中可以有abstract方法。和普通类相比，abstract类可以有abstract方法，也可以有非abstract方法。

abstract class A{

abstract int mina(int x,int y);

int max(int x,int y)｛

return x>y?x:y;

｝

}

（2）abstract类不能使用new运算符创建对象

抽象类只关注操作，即只关心方法的名字、类型以及参数，不关心这些操作的具体实现

  二、abstract类多态

使用多态进行程序设计的核心技术是使用上转型技术，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对象就可以调用子类的重写方法。

Animal.java

public abstract class Animal{

public abstract void cry();

public abstract String getAnimalName();

}

Simulator,java

public class Dog extends Animal{

public void play(Animal animal){

System.out.println("现在播放"+animal.getAnimalName()+"累的声音：");

animal.cry();

}

}

Dog,java

public class Dog extends Animal{

public void cry(){

system.out.println("汪汪汪");

}

public String getAnmialName(){

return "狗"; 

}

}

Cat,java

public class Cat extends Animal{

public void cry(){

system.out.println(”喵喵喵？");

}

public String getAnmialName(){

return "猫"; 

}

}

example.java

public class example{

public static void main(){

Simulator simulator =new Simulator();

simulato.playSound(new Dog());

simulato.playSound(new Cat());

}

}

5.8接口

java不支持多继承性，一个类只能有一个父类。为了克服单继承的缺点，java使用接口，一个类可以实现多个接口。



  一、接口的声明与使用

1、接口的声明

格式 interface 接口的名字

2、接口体

接口体包括常量的定义和方法的定义，接口中只有抽象方法，没有普通方法，并且接口体中所有常量的访问权限一定是public、所有抽象方法的访问权限是public。

interface Printable{

public final int MAX = 100;

public abstract void add();

public abstract float sum(float x,float y );

}

3、接口的使用

一个类使用关键字implements声明自己实现了一个或者多个接口，如果是实现了多个，用逗号隔开

class A implements Printable,Addable

class Dog extends Animal implements Printable,Addable

4、接口的理解

接口可以增加很多类都需要具有的功能，不同的类可以实现相同的接口，同一个类也可以实现多个接口。。。。。