JAVA-面向对象编程基础

1、面向对象概述

1.1 对象

在现实世界中，对象是事物存在的实体。而在计算机的世界中，面向对象程序设计的思想要以对象来思考问题，首先将现实世界的实体抽象为对象，然后考虑这个对象具备的属性和行为。
举个例子来说，如果有一只大雁要从北方飞往南方这个实际问题，我们首先可以从这一问题中抽象出大雁这个对象，然后识别出大雁的属性，比如有一对翅膀，有黑色的羽毛等等。随后，我们可以识别出这个对象的动态行为，即这只大雁可以进行的动作，比如飞行、觅食等，这些动作都是这个对象基于其属性而具有的动作。

1.2 类

类是同一类事物的统称，如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称，比如鸟类，家禽类等等。具有相同特征和行为的一类事物就称为类。
类与对象的关系可以如下来描述：类是世间事物的抽象称呼，而对象则是这个事物相对应的实体。

1.3 面向对象程序设计的特点

封装
封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。
类为用户提供对象的属性和行为的接口，用户通过这些接口使用这些类，无须知道这些类内部是如何构成的，不能操作类中的内部数据。

继承
类与类之间同样具有关系，继承是关联中的一种。举例来说，四边形中有平行四边形，梯形等等，平行四边形具有四边形的所有性质，比如有四条边，内角和为360度等等，但是，平行四边形也有普通四边形所不具备的特殊性质，比如两组对边平行等等。在JAVA中，我们将类似于平行四边形的类称为子类，将类似于四边形的类称为父类或者超类。

多态
多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象的语言中中，接口的多种不同的实现方式即为多态。比如四边形有绘制图像的能力，但是绘制怎样的四边形是不确定的，对于正方形，我们要绘制四条边相等的图形，对于平行四边形，我们要绘制两组对边互相平行的图形。在多态的机制中，父类通常被定义为抽象类并给出一个方法的标准，而不给出实现的具体流程。

2、类与对象

在JAVA中定义类使用class关键字，其语法如下

class 类名称{
  //成员变量
// 成员方法
}

我们直接用一个简单的例子来介绍一下类的一些基本元素

public class Basic_oop {
    public int x = 100;
    public int y = 100;


    public int getX(){
        return this.x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getSum(int x,int y){
        return x + y;
    }

    public void change(int[] x){
        for(int i=0;i<x.length;i++) {
            x[i] = 100 * i;
        }
    }

    public int getSum(int... x){
        int sum = 0;
        for(int i=0;i<x.length;i++){
            sum += x[i];
        }
        return sum;
    }

    public Basic_oop(){

    }
    public Basic_oop(int x,int y){
        this.x = x;
        this.y = y;
    }



    public static void main(String[] args){
        Basic_oop obj = new Basic_oop(5,4);
        System.out.println(obj.x);
        System.out.println(obj.y);
        int[] arr = new int[]{0,1,2};
        obj.change(arr);
        for(int i:arr){
            System.out.print(i + "\t");
        }

    }
}

成员变量
成员变量即对象的属性，可以看到，我们建立了一个Basic_oop的类，类的对象有两个属性，或者说是两个成员变量，分别是x和y。

成员方法
成员方法即类对象的行为，我们定义了获得属性值和设置属性值的set和get方法。同时，为了介绍成员方法的参数的概念，我们定义了两个getSum方法和一个change方法。那么在成员方法中传递参数，有三种方式。
(1)值参数
值参数表明实参与形参之间按值传递，因此对形参的修改不会引起实参的变化
(2)引用参数
如果在给方法传递参数时，参数的类型是数组或者其他引用类型，那么在方法中对参数的修改会反映到原有的数组或者其他引用类型上，这种类型的方法参数，称为引用参数。如上面的例子中，change方法修改了原来数组中的三个值，变成了0、100和200，那么打印将输出0、100和200。
(3)不定长参数
声明方法时，如果有若干个相同类型的参数，可以定义为不定长参数，在参数类型和参数名之间有三个点即可。比如上例中的第二个getSum方法。

构造方法
构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。对于构造方法来说，它没有返回值，名称必须要与被类的名称相同，在默认情况下，构造方法是没有参数的，当然我们也可以创建有参的构造方法，来完成对对象的参数的初始化。如

 public Basic_oop(int x,int y){
        this.x = x;
        this.y = y;
    }

** 对象的创建**
对象的创建使用new关键字，如果不传入参数，将调用默认的无参构造函数创建，如果带参数，则使用有参的构造函数创建：

Basic_oop obj = new Basic_oop(5,4);

访问对象的属性和行为
可以使用对象.类成员来获取对象的属性和行为。比如：

 System.out.println(obj.x);
 System.out.println(obj.y);
int[] arr = new int[]{0,1,2};
obj.change(arr);

对象的销毁
JAVA拥有一套完整的垃圾回收机制，Java虚拟机会回收无用的但占用内存的资源。那么那种对象会被Java虚拟机视为垃圾呢？主要有以下两种：

1、对象引用超过其作用范围；
2、将对象赋值为null。

但垃圾回收器只能回收由new操作符创建的对象。

this关键字
JAVA语言中，this关键字被用来代替本类对象的引用。

3、static关键字

由static修饰的变量，常量和方法被称为静态变量、静态常量和静态方法，也被称为类的静态成员。我们先来看一个例子：

public class Basic_oop_static {
    static public int water = 0;
    final static int inPerTime = 3;
    final static int outPerTime = 2;
    public void outlet(){//放水，一次两个单位
        if(water > outPerTime){
            water -= outPerTime;
        }
        else{
            water = 0;
        }
    }

    public void inlet(){//注水，一次3个单位
        water += inPerTime;
    }

    static public int printWater(){
        return water;
    }

    public static void main(String[] args){
        Basic_oop_static in = new Basic_oop_static();
        Basic_oop_static out = new Basic_oop_static();
        System.out.println("水池的水量"+Basic_oop_static.water);
        System.out.println("水池注水两次");
        in.inlet();
        in.inlet();
        System.out.println("水池的水量"+Basic_oop_static.water);
        System.out.println("水池放水两次");
        out.outlet();
        out.outlet();
        System.out.println("水池的水量"+Basic_oop_static.printWater());
    }
}

输出为：

水池的水量0
水池注水两次
水池的水量6
水池放水两次
水池的水量2

3.1 静态变量

如果想让同一类的不同实例对象共享同一个变量，那么可以将该变量定义为静态变量，如上面的water对象，类中不同对象对静态变量的修改，都会作用到其他该类的对象中，比如我们修改水池的水量，可以发现water变量是两个对象所共享的。

3.2 静态常量

由final static修饰的成员变量即为静态常量，静态常量由类的所有对象所共享，且不能被改变：

    final static int inPerTime = 3;
    final static int outPerTime = 2;

3.3 静态方法

调用静态方法，无需创建类的对象，直接用 ** 类名.静态方法() ** 调用即可。

Basic_oop_static.printWater();

3.4 静态代码块

staitc修饰的代码区域可以被称之为静态代码块。
1、静态代码块自始至终只运行一次，声明一个对象的时候就会运行静态代码块
2、非静态代码块每次创建对象时都会运行，并且会在构造方法之前云行
3、构造方法只有在使用new创建对象时才会运行
4、成员方法只有在使用对象调用时才会运行

我们来看一个例子:

public class StaticTest {
    static String name;
    static{
        System.out.println(name + "静态代码块");
    }

    {
        System.out.println(name + "非静态代码块");
    }

    public StaticTest(String a){
        name = a;
        System.out.println(name + "构造方法");
    }

    public void method(){
        System.out.println(name + "成员方法");
    }

    public static void main(String[] args){
        StaticTest s1;
        StaticTest s2 = new StaticTest("s2");
        StaticTest s3 = new StaticTest("s3");
        s3.method();
    }

}