面向对象特征
●面向对象语言的三大特征
封装
继承
多态
面向对象特征——封装
●封装的概念
•封装:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐
藏信息的操作和访问 。
•封装的好处:
1.只能通过规定方法访问
2.隐藏类的实现细节
3.方便加入控制语句
4.方便修改实现
•具体表现—使用不同的访问权限
public class Demo{
private String name;
public String getName (){
return name;
} public void setName(String name){
this.name = name;
}
}
面向对象特征——继承
●继承:继承是面向对象程序设计不可缺少的设计思想,是实现代码可重用的根基,是提高代码可扩展
性的主要途径
●继承是从已有的类中派生出新的类,新的类能吸收已有类的属性和行为,并能扩展新的能力
●在JAVA中使用extends关键字来表示继承关系
●JAVA不支持多继承,单继承使JAVA的继承关系很简单,一个类只能有一个直接父类
●继承之后子类可以调用父类的所有非私有属性和非私有方法
●继承的形式:
•访问权限修饰符 子类名 extends 父类名{子类体}
public class Animal{
public void eat(){}
}
public class Dog extends Animal{
public void play(){}
}
//子类对象可以直接调用父类的方法,强调复用性
Dog dog = new Dog ();
dog.eat();
●继承的传递性:
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关键字,为了防止数据在方法体中被修改
public class Ex{
private int a = 1;
private String b;
public void ww(final int a){
a=12;
}
}
接口
●可以使用Java接口来实现
USB接口本身没有实现任何功能
USB接口规定了数据传输的要求
USB接口可以被多种USB设备实现
编写USB接口 ---> 根据需求设计方法
实现USB接口 ---> 实现所有方法
使用USB接口 ---> 用多态的方式使用
●面向接口编程
程序设计时:
关心实现类有何能力,而不关心实现细节
面向接口的约定而不考虑接口的具体实现
•接口存在的意义:java中一个类只能有一个父类,所以用接口可以实现多继承的逻辑
•从本质上讲,接口是一种特殊的抽象类,这种抽象类中包含抽象方法
●认识一下接口
public interface MyInterface {
int num = 10;
public void foo();
public static void test(){
}
public default void test1(){
}
}
接口的定义和使用
接口的定义:使用 interface 关键字用来声明一个接口
[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]
{
// 声明常量 抽象方法 静态方法 默认方法
}
接口的使用:类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。
[访问修饰符] class 类名 implements 接口名1,接口名2……{ }
结合继承:
[访问修饰符] class 类名 extends 父类名 implements 接口名1,接口名2……{ }
接口的特性
•接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字
•接口中方法可以是抽象的,静态的,默认的
•接口中声明的属性默认为 public static final 的
•接口不是被类继承了,而是要被类实现
•接口不能实例化对象,无构造方法
•一个类可以实现多个接口
•与继承关系类似,接口与实现类之间存在多态性
•一个接口能继承其它多个接口
•当类实现接口的时候,类要实现接口中所有的抽象方法。否则,类必须声明为抽象的类