面向对象的基础

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

项目名称    面向对象程序设计    面向过程程序设计（也叫结构化编程）
定义    面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的“对象”，其基本思想是一切皆对象，是一种“自下而上”的设计语言，先设计组件，再完成拼装。    面向过程是“自上而下”的设计语言，先定好框架，再增砖添瓦。通俗点，就是先定好main()函数，然后再逐步实现mian()函数中所要用到的其他方法。
特点    封装、继承、多态    算法+数据结构
优势    适用于大型复杂系统，方便复用、    适用于简单系统，容易理解
劣势    比较抽象、性能比面向过程低    难以应对复杂系统，难以复用，不易维护、不易扩展
对比    易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护     性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 
设计语言    Java、Smalltalk、EIFFEL、C++、Objective-、C#、Python等    C、Fortran
使用场景    
30种编程语言的比较选择问题https://blog.csdn.net/ljy1988123/article/details/7782700

类与对象的主要区别

对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。 

类：类是一个模板，它描述一类对象的行为和状态。

1、面向对象三大主要特征（理解）
①封装

两层含义：一层含义是把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单元(即对象)中；另一层含义指“信息隐藏”，把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知晓，或只允许使用对象的功能，而尽可能隐藏对象的功能实现细节。

封装的优点

良好的封装能够减少耦合，符合程序设计追求“高内聚，低耦合”。

类内部的结构可以自由修改。

可以对成员变量进行更精确的控制。

隐藏信息实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person { 
    private String name; 
    private int age; 
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{ 
    private String name;
    private int age; ​ 
    private boolean alive;
 
    public int getAge(){
        return age; 
    } 
 
    public void setAge(int age){ 
        this.age = age; 
    } ​
 
    public String getName(){ 
        return name; 
    } ​
 
    public void setName(String name){ 
        this.name = name; 
    }
 
    public boolean isAlive() {
        return alive;
    }
 
    public void setAlive(boolean alive) {
        this.alive = alive;
    }
 
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

封装同时可以提高代码的安全性，例如普通的类属性不是private修饰就直接可以通过“对象名.属性 = xxx”对其赋值，但当我们用private修饰该属性后就不能这样对其做任意的修改了，而且我们还可以在其对外的访问方法中进行合法值校验。比如上例中的setAge()就可以更改为：

public void setAge(int age){
    if(age > 120)
        System.out.println("Age setting error");
    else
        this.age = age;
}

 封装的使用细节：

一般使用private访问权限
提供相应的get、set方法来访问相关属性，这些方法通常是public修饰的。以提供对属性的赋值与读取操作。（注意！boolean变量的get方法是is开头。）
一些只用于本类的辅助性方法，可以使用private修饰，希望其他类调用的方法用public修饰。
this与super关键字：

1、this关键字代表当前对象

2、super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。  

 this与super对比

this.属性 操作当前对象的属性
this.方法 调用当前对象的方法 
引用构造函数：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
普通的直接引用：与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。
子类中的成员变量或方法与父类中的成员变量或方法名同名时，表示调用父类的成员
引用构造函数：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。默认在构造函数第一条语句是“super();”，无论写与否。
super(参数)：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
this(参数)：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
super() 和 this() 类似,区别是，super() 从子类中调用父类的构造方法，this() 在同一类内调用其它方法。
super() 和 this() 均需放在构造方法内第一行。
尽管可以用this调用一个构造器，但却不能调用两个。
this 和 super 不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有 super 语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。包括：static 变量,static 方法，static 语句块。
从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。
②继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

类的继承格式：

class 父类 { }

class 子类 extends 父类 { }

继承的类型：需要注意的是 Java 不支持多继承，但支持多重继承。

 继承的好处：

(1)提高类代码的复用性

(2)提高了代码的维护性

(3)使得类和类产生了关系，是多态的前提(它也是继承的一个弊端，类的耦合性提高了)

继承的特性

子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法，即重写父类方法。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

 final关键字：

表示最终的意思，可以修饰类、成员变量、成员方法

修饰类：类不可以被继承
修饰成员变量：变量为常量，值不可以改变
修饰成员方法：方法不能被重写
final还可以修饰局部变量：①修饰基本数据类型，值不能改变；②修饰引用数据类型，地址值不能改变
 static关键字（静态）：

static表示静态的意思，既可以修饰成员变量，又可以修饰成员方法，还有一种特殊用法修饰类

(1)、修饰成员变量表示静态变量：static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。static不能修饰局部变量。

(2)、修饰成员方法：static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

(3)static代码块：static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

特点：
    1）随着类的加载而加载
    2）优先于对象存在
    3）被所有的对象所共享
        该特点是我们使用static的条件

注意事项：
    1）在静态方法中，不能出现this／super
    2）静态方法只能访问静态成员；非静态方法既可以访问静态成员，也可以访问非静态成员
    3）工具类里面的成员一般来说是静态成员（目的：节约内存空间）

静态变量和成员变量的区别
1）所属不同
      静态变量属于类，也称为类变量
      成员变量属于对象，也称为实例变量
2）内存中位置不同
      静态变量存在方法区
      成员变量存在堆中
3）出现的时间不同
      静态变量随着类的加载而加载，随着类的消亡而消亡
      成员变量随着对象的创建而创建，随着对象的消失而消失
4）调用方式不同
      静态变量通过类名调用，也可以通过对象名调用（不建议）
      成员变量只能通过对象名调用
所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据

成员变量与局部变量的区别
1）在类中的位置不同
       成员变量：在类中方法外面
       局部变量：在方法或者代码块中，或者方法的声明上（即在参数列表中）
2）在内存中的位置不同，可以看看Java程序内存的简单分析
       成员变量：在堆中（方法区中的静态区）
       局部变量：在栈中
3）生命周期不同
      成员变量：随着对象的创建而存在，随着对象的消失而消失
      局部变量：随着方法的调用或者代码块的执行而存在，随着方法的调用完毕或者代码块的执行完毕而消失
4）初始值
      成员变量：有默认初始值
      局部变量：没有默认初始值，使用之前需要赋值，否则编译器会报错（The local variable xxx may not have been initialized）

package se01.day02;
 
//子父类静态代码块、构造代码块、构造方法

class Fu{
    String name;
    int age;
    
    {
        System.out.println("构造代码块Fu");
    }
    
    static{
        System.out.println("静态代码块Fu");
    }
    
    public Fu() {
        System.out.println("无参构造方法Fu");
    }
 
    public Fu(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造Fu");
    }
 
}
public class Zi extends Fu{
    int id;
    {
        System.out.println("构造代码块Zi");
    }
    static{
        System.out.println("静态代码块Zi");
    }
    public Zi() {
        System.out.println("无参构造方法Zi");
    }
 
    public Zi(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造Zi");
    }
    public static void main(String[] args) {
        new Zi("小明",13);
    }
}

 
==========================执行结果为====================================
静态代码块Fu
静态代码块Zi
构造代码块Fu
无参构造方法Fu
构造代码块Zi
有参构造Zi

static特殊用法(static修饰类)：  如果一个类要被声明为static的，只有一种情况，就是静态内部类。如果在外部类声明为static，程序会编译都不会过。（在内部类中详细讲解）

Question：在什么情况下需对属性和方法加上static关键字？

在编写的代码中，static定义的属性出现几率不是特别高，一般只有在描述共享属性概念或者是不受实例化对象限制的属性时才会使用static定义属性，而大部分情况下依然都使用非static属性。

产生实例化对象是因为在堆内存中可以保存属性信息，所以如果一个类中没有属性产生，就自然也没有必要去开辟堆内存保存属性内容了，所以这个时候就可以考虑类中的方法全部使用static声明。

NOTICE:在JDK1.7之前，Java一直存在一个Bug，可以先执行静态代码块来代替主方法。按照标准来说，所有的程序应该都是从主方法开始执行，但是下例却先执行静态代码块

    public static void main(String[] args) {
        System.out.println("你好,世界");
    }
    
    static{
        System.out.println("Hello World");
    }
 

===========输出结果为==============
Hello World
你好,世界
③多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态的体现
Java语言中含有方法重载与对象多态两种形式的多态：

方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。

对象多态：子类对象可以与父类对象进行转换，而且根据其使用的子类不同完成的功能也不同（重写父类的方法）。

面试题：什么是多态？实现多态的方法有哪些？

多态是面向对象的最后一个主要特征，它本身主要分为两个方面：
       ·方法的多态性：重载与覆写
            |-重载：同一个方法名称，根据不同的参数类型及个数可以完成不同的功能。
            |-覆写：同一个方法，根据操作的子类不同，所完成的功能也不同。
       ·对象的多态：父子类对象的转换。
            |-向上转型：子类对象变为父类对象，格式：父类 父类对象 = 子类实例，自动；
            |-向下转型：父类对象变为子类对象，格式：子类 子类对象 = (子类)父类实例，强制。

多态的优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性