面向对象

　　Java语言是面向对象的程序设计语言，有三大特征：封装、继承和多态。Java语言完全以对象为中心，Java程序的最小程序单位是类。

一、了解面向对象

 1.面向对象的含义

　　类可以生成系统中的多个对象，这些对象直接映像成客观世界的各种事物，面向对象开发的软件系统逻辑上的组成结构如下

 　　面向对象的软件系统由多个类组成，这些类事物往往有一些内部的状态数据，程序只需要记录需要的数据即可。

　　Java使用类来封装一类事物的内部状态数据，类会提供操作这些状态数据的方法，还会为这类事物的行为特征提供相应的表现，这种实现也是方法，

　　成员变量  +  方法  =  类定义

 2.面向对象的三大特征

　　面向对象有三个基本特征：封装、继承和多态，封装是指将对象的实现细节隐藏起来，通过一些公用方法来暴露该对象的功能；继承是面向对象实现软件复用的重要手段，子类可以继承父类，子类作为一种特殊的父类，可以直接获得父类的属性和方法，多态是指子类对象可以直接赋给父类变量，但运行时依然表现出子类的行为特征，即一个类型的对象在执行同一个方法时，可能表现出多种行为特征。

二、构造器、变量与方法

　1.深入构造器

　　构造器是一个特殊的方法，用于创建类实例时执行初始化。构造器是创建对象的重要途径，因此，Java类必须包含一个或一个以上的构造器。

　　当使用构造器创建一个对象时，系统会为这个对象的实例变量进行默认初始化，会把所有基本类型的实例变量设为0(数值类型实例变量)或false(布尔类型实例变量)，把所有引用类型的实例变量设为null。系统默认会提供一个构造器，也可以自己定义一个构造器，当定义了一个构造器后，就不会使用系统默认的构造器，可以定义多个构造器，如果一个类里面提供了多个构造器，那么就构成了构造器的重载。

package Advance;

public class Test {
    public int age;
    public String name;
    public Test(){}
    public Test(int age,String name){
        this.name = name;
        this.age = age;
    }
    public static void main(String[] args) {
        Test t1 = new Test();
        Test t2 = new Test(18, "吴彦祖");
        //0 null
        System.out.println(t1.age +" "+t1.name);
        //18 吴彦祖
        System.out.println(t2.age+" "+t2.name);
    }
}

　2.成员变量与局部变量

　　

•  类变量：从类的准备阶段开始存在，直到系统完全销毁这个类，类变量的作用域与这个类的生存范围相同
• 实例变量：从该类的实例被创建起开始存在，直到系统完全销毁这个实例，实例变量的作用域与对应实例的生存范围一致
• 形参：在定义方法1签名时定义的变量，形参的作用域在整个方法内有效
• 方法局部变量：在方法体内定义的局部变量，作用域是从定义该变量的地方生效，到方法结束时失效
• 代码块局部变量：在代码块中定义的局部变量，这个局部变量的作用域从定义该变量的地方生效，到该代码块结束时生效

　　与成员变量不同，局部变量除了形参之外，都必须显式初始化。如果方法里的局部变量与成员变量同名，局部变量会覆盖成员变量，如果需要调用被覆盖的成员变量，则可使用this或类名作用调用者来限定访问成员变量。

　3.方法详解

　　方法是类或对象的行为特征的抽象，方法是类或对象最重要的组成部分。Java里的方法的参数传递方式只有一种：值传递。所谓值传递，就是将实际参数值的副本(复制品)传入方法内，而参数本身不会受到任何影响

　　1、基本类型的值传递

package Advance;

public class Test {
    public  static void swap(int a,int b){
        int temp = a;
        a = b;
        b = temp;
        //swap中a = 8, b = 4
        System.out.println("swap中a = "+ a +", b = "+b);
    }
    public static void main(String[] args) {
        int a = 4;
        int b = 8;
        swap(a,b);
        //main中a = 4, b = 8
        System.out.println("main中a = "+ a +", b = "+b);
    }
}

　　此时系统会产生两个栈区，分别是main栈区和swap栈区，两个栈区分别存储着a、b变量的值 4,8；当swap栈区的a、b值进行交换时，并不会影响到main栈区的值，所以main栈区的值并不会产生任何改变

　　2、引用类型的值传递

package Advance;

class DataWrap{
    int a;
    int b;
}
public class Test {
    public  static void swap(DataWrap dw){
        int temp = dw.a;
        dw.a = dw.b;
        dw.b = temp;
        //swap中a = 8, b = 4
        System.out.println("swap中a = "+ dw.a +", b = "+dw.b);
    }
    public static void main(String[] args) {
        DataWrap dw = new DataWrap();
        dw.a = 4;
        dw.b = 8;
        swap(dw);
        //main中a = 8, b = 4
        System.out.println("main中a = "+ dw.a +", b = "+dw.b);
    }
}

　　系统会产生两个栈区，分别是main栈区和swap栈区，还有一个存储DataWrap对象的堆区，两个栈区的对象dw都是指向堆区的DataWrap对象，存储的都是指向堆区的地址，当swap栈区的地址值发生改变时，main栈区的地址值也会发生改变，所以系统只复制了dw变量，但并未复制DataWrap对象，造成值发生改变的假象。

　　当程序在swap()方法中操作dw形参时，由于dw只是一个引用变量，故实际操作的还是堆内存的DataWrap对象。此时，不管是操作main()方法的dw变量，还是操作swap()方法的dw参数，实际上操作的都是引用的DataWrap对象，它们引用的是同一个对象。

 　　(3)、递归方法

　　一个方法体内调用它自身，被称为方法递归。递归一定要向已知的方向递归。

package Advance;

/**
 * f(0) = 1;f(1)=4;f(n+2)=2*f(n-1)+fn(n)
 */
public class Recuer {
    public static int fn(int n){
        if(n==0){
            return 1;
        }else if (n==1){
            return 4;
        }else {
            return 2*fn(n-1)+fn(n-2);
        }
    }
    public static void main(String[] args) {
        //10497
        System.out.println(fn(10));
    }
}

三、封装

 　　将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法类实现对内部信息的操作和访问。封装可以实现以下目的：

• 隐藏类的实现细节
• 让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问
• 可进行数据检查，从而有利于保证对象信息的完整性
• 便于修改，提高代码的可维护性

　　从两个方面考虑封装：

• 将对象的成员变量和实现细节隐藏起来，不允许外部直接访问
• 把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作

　　Java使用控制符来实现封装：

四、继承

 　　Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类。Java类只能由一个直接父类，但是可以有无限多个间接父类

class Fruit extends Plant{...}
class Apple extends Fruit{...}

　　子类可以重写父类的方法，要求方法名相同、形参列表相同；子类方法返回值类型和抛出的异常类应该必父类的更小或相等；子类方法的访问权限应比父类方法的访问权限更大或相等。重写的方法要么都是类方法，要么都是实例方法。使用super可以调用父类被覆盖的方法

五、多态

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