面向对象

 

面向对象三大特性：

一、封装：

　　封装性就是把类（对象）的属性和行为结合成一个独立的相同单位，并尽可能隐蔽类（对象）的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。封装的特性使得类（对象）以外的部分不能随意存取类（对象）的内部数据（属性），保证了程序和数据不受外部干扰且不被误用。

通过访问修饰符来限制对类的属性和方法的访问：

         Private:成员变量和方法只能在类内被访问，具有类可见性

         默认： 成员变量和方法只能被同一个包里的类访问，具有包可见性。

         Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问

         Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限

二、继承：

1、Java的继承具有单继承的特点，即只能继承自一个父类，每个子类只有一个直接父类，但是其父类又可以继承于另一个类，从而实现了子类可以间接继承多个父类，但其本质上划分仍然是一个父类和子类的关系。

2、Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类(有的也称其为基类、超类)，父类和子类的关系，是一种一般和特殊（is-a）的关系。就像是水果和苹果的关系，苹果继承了水果，苹果是水果的子类，水果是苹果的父类，则苹果是一种特殊的水果。

 3、继承关系是传递的。若类C继承类B，类B继承类A（多继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的，但仍是类C的属性和方法。继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。    
4、继承提供了功能复用。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。

如果在子类中需要访问父类中定义的同名成员变量或方法，需要用的关键字super。Java中通过super来实现对被隐藏或被 覆盖的父类成员的访问。super 的使用有三种情况：

1、访问父类被隐藏的成员变量和成员方法；

      super.成员变量名;

2、调用父类中被覆盖的方法，如：

      super.成员方法名([参数列])

3、调用父类的构造函数，如

     super([参数列表]);

super()只能在子类的构造函数中出现，并且永远都是位于子类构造函数中的第一条语句。

new子类时如果子类构造方法中没有super()方法，程序会先去调用父类的构造方法，然后再调用子类的构造方法。子类构造方法中没有写super()方法，会默认调用super()。

    
    
public class Test{
    public static void main(String arg[]) {
        SonClass son1 = new SonClass();
        SonClass son2 = new SonClass(100);
    }
}
class FatherClass {
    FatherClass() {
        System.out.println("FatherClass类无参构造函数");
    }
    FatherClass(int num) {
        System.out.println("FatherClass类有参构造函数：" +num);
    }
}
class SonClass extends FatherClass {
    SonClass(int num) {
        System.out.println("SonClass类有参构造函数：" + num);
    }
    SonClass() {
        super(500);
        System.out.println("SonClass类无参构造函数");
    }
}

输出结果：

FatherClass类有参构造函数：500

SonClass类无参构造函数

FatherClass类无参构造函数

SonClass类有参构造函数：100

三、多态

         1、多态性是指在继承关系中的父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各子类类中具有不同的含义。

            2、 Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的 多态 　

　

   
   
public class Test{

    public static void main(String arg[]) {
        Fruits fruits;
        fruits=new Fruits();
        fruits.readName();

        fruits=new Apple();
        fruits.readName();

        fruits=new Pear();
        fruits.readName();
    }
}
class Fruits  {
    void readName() {
        System.out.println("我是水果");
    }
}

class Apple extends Fruits {
    void readName(){
        System.out.println("我是苹果");
    }
}

class Pear extends Fruits {
    void readName(){
        System.out.println("我是鸭梨");
    }
}

输入结果：

我是水果

我是苹果

我是鸭梨

面向对象与面向过程编程的区别：

面对对象编程：

         把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。

面向过程编程：

          自顶向下顺序执行，逐步求精；其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构；各模块之间的关系尽可能简单，在功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成；其模块化实现的具体方法是使用子程序。程序流程在写程序时就已决定