面向对象特征

●面向对象语言的三大特征

封装

继承

多态

面向对象特征——封装

●封装的概念

•封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐

藏信息的操作和访问。

•封装的好处：

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 的

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

•接口不能实例化对象,无构造方法

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

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

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

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