java第七课面向对象

面向对象特征–继承

l继承：继承是面向对象程序设计不可缺少的设计思想，是实现代码可重

用的根基，是提高代码可扩展性的主要途径。

● 继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为， 并能扩展新的能力。

● 在JAVA中使用extends关键字来表示继承关系。

● JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个

直接父类。

● 继承之后子类可以调用父类的所有非私有属性和非私有方法

●何时使用继承？

●继承与真实世界类似

●只要说“猫是动物”

●狗也是动物

符合is-a关系的设计,使用继承

将子类共有的属性和行为放到父类中

● 继承是代码重用的一种方式

● 继承的形式：

● [访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}

public class Animal{

public void eat(){}

}

public class Dog extends Animal{

public void play(){}

}

子类对象可以直接调用父类的方法，强调复用性

Dog dog = new Dog ();

dog.eat();

专业术语

·Dog类是 Animal类的子类, Animal类是Dog类的父类

·Dog类是 Animal类的派生类, Animal类是Dog类的基类

继承的传递性

C类从B类继承,B类又从A类继承

那么C类就具有B类和A类的所有非私有属性和非私有方法

当一个没有继承任何一个类时,jvm会默认让类继承Object类

Object是 java为所有类提供的基类

● 继承中的构造方法

子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法

可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法

如果用super,必须写在构造方法的第一句

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无

参数的构造方法。

●super关键字用途

● super关键字代表父类的引用，在程序中主要的用途

• 在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现 在子类构造方法体的第一行。

• 用“super.成员变量名”来引用父类成员变量

• 用“super.方法名（参数列表）”的方式访问父类的方法。

● 方法的重写(OverRide)

● 应用场景

当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)

● 在子类中可以根据需要对从基类中继承来的方法进行重写。

● 方法重写规则

• 方法名相同、参数列表相同；

• 返回值类型相同；

• 访问权限不能小于父类权限;

注意：构造方法,静态方法不能重写,成员变量不存在重写

抽象类

● 抽象方法

• 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现.

• 抽象方法必须用abstract关键字进行修饰

● 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象 类。

● 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方 法和构造方法。

● 用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必 须定义成抽象类。

● 特点:

• 抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法， 所以不能用抽象类创建对象。

● 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实 现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一 样。否则，该类也必须声明为抽象类。

● 使用关键字abstract定义抽象类，一般语法：

[访问权限] abstract class 类名 {
成员列表
} 
public abstract class Shapes {
public abstract void draw();
}
public abstract class Shapes {
public void draw(){ 
//具体代码 
} 
}

● 抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，

设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并

覆盖抽象方法，实现具体功能。

面向对象特征–多态

● 多态

同一种事物，在不同时刻表现不同的状态

● 多态存在的三个必要条件

● 要有继承（包括接口的实现）(前提条件)

● 要有重写(前提条件)

● 父类引用指向子类对象

• 当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class Animal{ 
…… 
}
class Cat extends Animal{
…… 
}
class Dog extends Animal {
…… 
}
Animal x = new Cat() //Animal 的引用指向Cat的对象

●多态环境下对成员方法的调用

class Animal{ 
void show() {
System.out.println(“Anmial"); 
} 
}
class Cat extends Animal{
void show() {
System.out.println(“cat"); 
} 
}……. 
Animal x = new Cat() x.show() //调用的是子类中的方法 简单的说：编译看左边，运行看右边。

● 多态环境下对静态成员方法的调用

class Animal{ static void show() { 
System.out.println(“Animal"); 
} 
}
class Cat extends Animal { 
static void show() { 
System.out.println(“Cat"); 
} 
}……. 
Animal x = new Cat() x.show() //调用的是动物类中的静态成员方法。 简单的说：编译和运行都看左边

●多态环境下对成员变量的调用

class Animal{ 
int num = 3; 
}
class Cat extends Animal {
int num = 4; 
}……. 
Animal x = new Cat() x.num; //调用的是动物类中的成员变量。 简单的说：编译和运行都看等号左边。 注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

●方法参数具有多态性

class Animal{ 
void eat() {

} 
}
class Cat extends Animal{ 
void eat() {

} 
}
class Dog extends Animal{
void eat(){

} }
//方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象 
method(Animal animal){ 
animal .eat(); 
} 方法参数多态性的好处：提高代码的扩展性

● 向上转型

class Animal{ 
void eat(){ 
} }
class Cat extends Animal{ 
void look() {
System.out.println("看家");
} 
} ……… 
Animal x=new Cat() //向上造型，Cat对象提升到Animal对象 
x.eat() //只能使用父类中的方法 
x.look() //报错！不能使用子类中的方法
向上转型的作用是：提高程序的扩展性。

● 向下转型

class Animal{
void eat(){
} 
}
class Cat extendsAnimal{
void look() { 
System.out.println("看家");
} 
} ……… 
Animal x=new Cat() Cat m=(Cat)x; //向下转型 
m.eat() ;
m.look();//子父类中的方法都可以使用 向下转型的作用是：为了使用子类中的特有方法。

final关键字

● final 用于声明属性，方法和类。

• 属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能 修改。

• 方法:子类里不可以重写。

• 类:不能被定义为抽象类或是接口,不可被继承。

private int index;
private static final double pai=3.14;
private final int level; 
public Test(){
level=0;
}
public Test(int index){ 
this.index=index;
level=1;
}
● final属性赋值 
● 在声明时同时赋值，往往与 static一起使用。
● 声明时不赋值，必须在构造方法中 逐一赋值。 
● 总的原则：保证创建每一个对象的 时候，final属性的值是确定的。

● 对参数做final修饰。

• 在方法参数前面加final关键字，为了防止数据在方法体中被修改。

接口

● 可以使用Java接口来实现

USB接口本身没有实现任何功能

USB接口规定了数据传输的要求

USB接口可以被多种USB设备实现

编写USB接口-- 根据需求设计方法

实现USB接口–实现所有方法

使用USB接口–用多态的方式使用

● 认识一下接口

public interface MyInterface {
int num = 10;//所有属性默认为: public static final
public void foo()；//所有方法都是：public abstract
//其他方法 }

● 必须知道的接口特性

● 接口不可以被实例化

● 实现类必须重写接口的所有方法

● 实现类可以实现多个接口

● 接口中的变量都是静态常量

●面向接口编程

• 接口存在的意义：java中一个类只能有一个父类，所以用接口可以实现多继 承的逻辑 。

• 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的

定义，而没有变量和方法的实现。

接口的定义和使用

接口的定义：使用 interface 关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]

{

// 声明常量 抽象方法 静态方法 默认方法

}

**接口的使用：**类使用implements关键字实现接口。在类声明中，Implements关

键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

接口的特性

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

• 接口中方法可以是抽象的,静态的,默认的。

• 接口中声明的属性默认为 public static final 的；

• 接口不是被类继承了，而是要被类实现。

• 接口不能实例化对象（无构造方法），但可以声明对象的引用。（多态 性）

• 多个类可以实现同一个接口。

• 一个类可以实现多个接口，但只能继承一个类。

• 与继承关系类似，接口与实现类之间存在多态性。

• 一个接口能继承其它多个接口。

• 当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明 为抽象的类