Java面向对象思想

面向对象编程(Object-Oriented Programming , OOP)

以类的方式组织代码，以对象的组织(封装)数据。

类:一类事物共同特征的抽象描述。

对象:类的具体实例。

四种访问修饰符：

• public:公共--可以在任意类任意包中访问
• private:私有--只允许在本类中访问
• protected:受保护的--允许在本类，本包，子类中访问
• 默认的--允许在本类，本包中访问

super：

1. 在子类的方法中通过super调用父类的属性以及方法。
2. 在子类的构造方法中调用父类的构造方法,必须写在第一行。
3. private 只能被本类访问，super也无法访问。
4. super和this不能同时调用构造方法。

this：可用来引用当前类的实例变量，作为参数在构造函数调用中传递，从方法返回当前类的实例。

static：

1. 静态区和程序一起加载。
2. 静态变量可以用类名.访问。
3. 静态方法直接调用。

方法

Java方法是语句的集合，它们在一起执行一个功能。

1. 方法是解决一类问题的代码块。
2. 方法包含于类或对象中

构造方法

系统会给所有的类提供一个默认的无参构造方法,该方法是隐藏的,如果显式的写了自定义构造方法,那么系统默认的无参数构造方法就会销毁。

构造方法没有返回值(void都没有)，并且方法名必须和类名一致。

1. 用来创建对象，也就是对象在创建之前必须要执行构造方法。

修饰符 className(参数列表){
    方法体;
}

定义

方法包含一个方法头和一个方法体

修饰符 返回值类型 方法名(参数类型 参数名){
    方法体
    return 返回值;
}

修饰符(可选)：告诉编译器如何调用该方法，定义了该方法的访问类型。

返回值类型：方法可能会返回值，void方法没有返回值。

方法名：方法的实际名称，方法名和参数表共同构成方法签名。

参数类型：参数像是一个占位符，当方法被调用时传递值给参数，这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

方法体：方法体包含具体的语句，定义该方法的功能。

形式参数：在方法被调用时用于接收外界输入的数据。

实际参数：调用方法时实际传给方法的数据。

调用

对象名.方法名(实参列表)

方法重写

重写需要有继承关系，子类重写父类的方法。

当子类继承至父类的方法不满足子类的业务逻辑时需要重写子类继承的该方法。

重写是方法的重写，和属性无关。

@Override：有功能的注释。

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大但不能缩小

   public>protected>default>private

4. 抛出的异常：范围可以被缩小但不能扩大。

方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法重载的规则：

1. 方法名称必须相同
2. 参数列表必须不同(个数不同，类型不同，参数排列顺序不同等)
3. 方法的返回类型可以相同或不同
4. 返回类型不同不足以称为方法的重载

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等逐个匹配，选择对应的方法，匹配失败编译器会报错。

可变参数

在方法声明中，在指定参数类型后加一个省略号(...)

JDK1.5开始，Java支持传递同类型的可变参数给一个方法

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明

//排序
public class Test {
    public static void main(String[] args) {
        printMax(34,3,5,9,7,6);
        printMax(new double[]{1,2,3});
    }
    //输出最大值，不确定传递几个数
    public static void printMax(double... numbers){
        if (numbers.length == 0){
            System.out.println("No argument passed");
            return;//终止方法
        }
        double result = numbers[0];

        //排序
        for(int i = 1;i < numbers.length;i++){
            if (numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max value is "+ result);
    }
}

递归

方法调用方法，自己调用自己

利用递归可以用简单的程序来解决一些复杂的问题。把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，用少量的程序描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

//阶乘
public class Test {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int n){
        if (n == 1){
            return 1;//结束方法，结束递归
        }else{
            //n*n-1 的阶乘
            return n*f(n-1);
        }
    }
}

属性

全局属性：直接定义在类中的属性。

局部属性：定义在方法内的属性。

区别:

1. 全局属性在使用前如果不赋值,系统会赋默认值,局部属性在使用前必须赋值。

2. 局部变量的名字可以和全局变量一致,但是使用时默认使用局部变量,不建议名字一致。

3. 全局变量的作用域是整个类,局部变量作用域在方法内。

参数：方法在执行之前需要动态的给定一些数据,那么这些数据就通过参数的方式传递到方法内部。

1. 在调用该方法时传递的参数类型以及顺序必须和定义时一致。

2. 如果方法有返回值在定义方法的必须把void替换成对应类型返回值,方法执行完后必须在最后使用return返回对应类型的结果。

封装

1. 所有属性必须私有化，根据需求提供get/set方法
2. 属性:私有化属性，并且给每个属性提供get/set方法对其访问
3. 方法:把相同的功能代码集中写在方法中，方法一般是public

继承

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。在程序设计中可以通过继承来删减同一类事物的相同代码。降低类之间的耦合。

instanceof：判断有无父子关系

1. 子类继承父类非私有属性和方法。
2. 子类无法继承父类的构造方法。但是子类在创建对象之前必先创建父类对象(在子类的构造方法中会默认调用父类的无参构造方法)。
3. Java只能单继承,一个类只能有一个直接父类。
4. 如果子类重写了父类中的方法,不管怎么调用全部执行的是子类重写后的方法。
5. 在Java中(除了8种基本数据类型),所有的类全部直接或间接的继承Object方法。

多态

多态是方法的多态，属性没有多态性。

同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型很多。

多态存在的条件：

1. 有继承关系。
2. 子类重写父类方法。
3. 父类引用指向子类对象。

三种方法无法被重写，所以没有多态

1. static 方法
2. final常量
3. private方法

包机制

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。

为了能够使用某一个包的成员，需要在程序中导入该包。

package ... //使用该包下的所有对象
import ... //导入该包下的所有对象

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。

1. 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

2. 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。

3. 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

4. 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

5. 抽象类就是来实现封装，多态的，增强代码的可扩展性。

接口

声明接口的关键字是interface

Java中的类只能单继承，但接口可以多继承。

接口：只有规范！自己无法写方法_{专业的约束！约束和实现分离：面向接口编程}

接口不能被实例化，接口中没有构造方法

类可以实现接口 implements接口，实现接口的类，就需要重写接口中的方法。

内部类

内部类就是在一个类的内部再定义一个类。

1. 成员内部类

2. 静态内部类

3. 局部内部类

4. 匿名内部类

一个Java类中可以有多个class类，但是只能有一个public class