面向对象语言的三大特征

目录

一、封装 

二、继承

继承中的构造方法

方法重写

抽象类

 三、多态

一、封装 

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

隐藏信息的操作和访问 。

public class Person {

      private String name;
      private int age;

      public Person() //无参构造方法{
      }

      public Person(String name, int age) {
        if(name.length()<5){//控制语句
            this.name = name;
        }
        this.age = age;
     }

     /*
         为了不让外界直接访问成员变量,把成员变量私有化,
         但是必须还要为外界提供可以访问的方法(获取,赋值)
         为私有属性提供两个公共方法,一个用来赋值,一个用来获取值
      */
      public void setName(String name){
          //在我们的程序内部可以加入一些控制语句
          if(name!=null && name.length()<5){
              this.name = name;
          }
      }
      public String getName(){
           return  this.name;
      }

      public void setAge(int age){
          this.age = age;
      }
      public int getAge(){
          return this.age;
      }
}

 可以私有化构造方法，外界就不能随意的创建对象。

public class Window {

       private static Window window = null; //定义了一个静态成员,只有一个

      /*
         将构造方法私有化,外界就不能直接访问,也就不能随意的创建对象了.
         但是外界还是需要这个对象的,
         在类的内部提供一个方法用来获取创建的唯一的一个对象.
       */
      private Window(){

      }

      public static Window getWindow(){
                 if(window==null){
                     window = new Window();
                 }
                 return window;
      }
}

二、继承

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

  在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 类的所有非私有属性和非私有方法

继承中的构造方法

子类构造方法会先调用父类构造方法

使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行 ，如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无 参数的构造方法

使用super关键字访问父类成员

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

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

• 用super.构造方法(参数列表)访问父类构造方法

注意: 不要把super误认为是父类对象.在创建子类对象时,

不会创建父类对象.

只会将父类中的信息加载到子类对象中存储

方法重写

当父类中方法的具体实现 不能满足子类的需求时,可以在子类中定义与父类中结构相同的方法.

覆盖掉父类中方法,在子类中可以自己来实现功能.

方法重写规则

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

• 返回值类型相同；

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

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

抽象类

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

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

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

抽象方法

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

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

注意：

抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实 现其中的所有抽象

方法，而已实现方法的参数、返回值要和抽象类中的方法一 样。否则,该类也必须声明为抽象类。

public abstract class Animal{

    private  String name;

    public Animal(){

    }

    /*
         子类中的实现方式与父类中的实现方式都不同,那么在父类中没有必要实现功能.
         使用abstract修饰的方法叫抽象方法, 可以没有方法体,只是用来定义功能,不能直接被调用.
     */
    public abstract void eat();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/*
   Dog继承的是一个抽象类,里面包含了抽象方法
     1.实现抽象类中的抽象方法
     2.将当前类 也定义为抽象类
 */
public abstract class Dog  extends Animal {


       private String type;//品种 类型


       public abstract void play();


        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }


}

/*
  XiaoTianQuan类继承Dog抽象类
  对抽象方法进行实现
*/
public class XiaoTianQuan extends Dog {

    @Override
    public void play() {
        System.out.println("狗会玩");
    }

    @Override
    public void eat() {
        System.out.println("哮天犬吃东西");
    }
}

 三、多态

● 多态

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

多态存在的三个必要条件

要有继承（包括接口的实现） ( 前提条件 )       要有重写( 前提条件 )      父类引用指向子类对象 

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

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

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{

int num = 3;

}

class Cat extends Animal {

int num = 4;

}

…….

Animal x = new Cat()

x.num; //调用的是动物类中的成员变量。

简单的说：编译和运行都看等号左边。

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。