Java基础-面向对象（一）-修饰符、类和对象、方法、成员变量和局部变量

Java基础

面向对象（一）

一、Java修饰符

访问控制修饰符

default：（默认，什么都不写）同一包内可见。使用对象：类、接口、方法、变量。

private：同一类内可见， 使用对象：变量、方法。

public : 对所有类可见。使用对象：类、接口、变量、方法。

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。

访问控制和继承
请注意以下方法继承的规则：

父类中声明为 public 的方法在子类中也必须为 public。

父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。

父类中声明为 private 的方法，不能够被继承。

非访问修饰符

static 修饰符，用来修饰类方法和类变量。 静态方法不能使用类的非静态变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。 final 修饰符通常和 static 修饰符一起使用来创建类常量。

abstract 修饰符，用来创建抽象类和抽象方法。 一个类不能同时被 abstract 和 final 修饰。 抽象方法不能被声明成 final 和 static。

synchronized 和 volatile 修饰符，主要用于线程的编程。

二、类和对象

2.1定义类

类（class）是某一批对象（object）的抽象。对象是类的实例。

语法格式：

    修饰符 class 类名{
        零到多个构造器定义
        零到多个属性定义
        零到多个方法定义
    }

注：构造器名必须和类名相同，构造器即不能定义返回值的类型，也不能使用void。构造器省略系统将提供一个默认的构造器，是没有参数的。

构造器语法格式：

修饰符 构造器名(形参列表){
    可执行语句构成构造器执行体
}

示例：

public class Person {
    //    定义属性
    String name;
    int age;

    //    定义说话方法
    public void say(String word) {
        System.out.println(word);
    }
}

2.2对象

创建对象的根本途径是构造器，通过new关键字调用类的构造器来创建这个类的实例。

例如实例化前面的Person类：

Person person = new Person();

public class Person {
    //    定义属性
    String name;
    int age;

    //    定义说话方法
    public void say(String word) {
        System.out.println(word);
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.age = 20;
        person.name = "张三";
        person.say("我是张三！");
        System.out.println(person.age);
        System.out.println(person.name);
    }
}

对象的this关键字引用

this关键字总是指向调用该方法的对象。根据this的位置不同，有两种情形：

构造器中引用该构造器正在初始化的对象；

在方法中引用调用该方法的对象。

三、方法

方法不能独立存在，方法必须属于类或对象。如果这个方法被static修饰，则这个方法属于这个类，否则属于这个类的实例。因此方法调用必须使用类或者对象作为调用者，即“类.方法”或者“对象.方法”的形式调用。

3.1方法的参数传递

如果声明方法时包含了形参声明，那么调用方法时必须给这些形参指定参数值，也被称为实参。

方法传递参数的机制只有一种：值传递。即将实参的副本传入方法内，参数本身不受影响。

示例：

public class MethodTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        sum(a, b);
        System.out.println("main方法里的a是：" + a);
        System.out.println("main方法里的b是：" + b);
    }

    public static void sum(int a, int b) {
        a = a + b;
        b++;
        int sum = a + b;
        System.out.println("sum方法的a是：" + a);
        System.out.println("sum方法的b是：" + b);
        System.out.println("a+b的和是：" + sum);
    }
}

结果b

sum方法的a是：15
sum方法的b是：6
a+b的和是：21
main方法里的a是：10
main方法里的b是：5

可以看出传入参数只是实参的副本（值），对实参本身没有影响。

引用类型作为传入参数时，对象操作会修改对象属性本身的值。

示例：

public class MethodTest {
    public static void main(String[] args) {
        Number number = new Number();
        sum(number);
        System.out.println("main方法里的a是：" + number.a);
        System.out.println("main方法里的b是：" + number.b);
    }

    public static void sum(Number number) {
        number.a = number.a + number.b;
        number.b++;
        int sum = number.a + number.b;
        System.out.println("sum方法的a是：" + number.a);
        System.out.println("sum方法的b是：" + number.b);
        System.out.println("a+b的和是：" + sum);
    }
}

class Number {
    int a = 10;
    int b = 5;
}

结果：

sum方法的a是：15
sum方法的b是：6
a+b的和是：21
main方法里的a是：15
main方法里的b是：6

3.2 递归方法

一个方法体内调用它自身，被称为方法递归，方法递归包含了一种隐式的循环，无需循环控制。

示例：

public class Recursive {
    public static int fn(int n) {
        if (n == 0) {
            return 1;
        } else if (n == 20) {
            return 2;
        } else {
            return fn(n + 2) + fn(n + 2);
        }
    }

    public static void main(String[] args) {
        System.out.println(fn(10));
    }
}

结果：

64

3.3 方法重载

如果同一个类中包含了两个或两 个以上方法的方法名相同，但形参列表不同，则被称为方法重载。

可以看出，Java中确定一个方法需要三个要素：

①调用者，也就是方法的所属者，既可以是类，也可以是对象。

②方法名，方法的标识。

③形参列表，当调用方法时，系统将会根据传入的实参列表匹配。

方法重载的要求是同一类中方法名相同，参数列表不同，与其他无关。

示例：

public class Overload {
    public void test() {
        System.out.println("没有参数！！");
    }

    public void test(String msg) {
        System.out.println("有一个参数，参数是：" + msg);
    }

    public static void main(String[] args) {
        Overload overload = new Overload();
        overload.test();
        System.out.println("+++++++++++++++++++++++");
        overload.test("我就是参数！！！");
    }
}

结果：

没有参数！！
+++++++++++++++++++++++
有一个参数，参数是：我就是参数！！！

四、成员变量和局部变量

成员变量是指在类范围内定义的变量，局部变量是指在方法里面定义的变量。

4.1 成员变量的初始化和在内存中的运行机制

当系统加载类或创建类的实例的时候为成员变量分配内存空间并自动为成员变量指定初始值。

4.2 局部变量的初始化和在内存中的运行机制

定义局部变量后必须显式初始化后才能使用，系统不会为局部变量初始化，意味着并没有给这个变量分配内存空间，直到程序为这个变量赋初始值的时候才会分配内存，并将初始值保存在内存中。