面向对象基础

• class好比是人类，instance好比是指定的某个人

• person类型，类似于C语言中的结构体

方法(看的不是很懂，感觉思路不清晰)

• 一个class可以包含多个field（field即为领域，private私有域，protected保护域，public公共域，publicstatic公共静态域）
• 直接操作field容易造成逻辑混乱，我们可以用private修饰field，拒绝外部访问，但是可以、使用方法（method）来让外部代码可以间接修改field：

public方法

public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        ming.setName("Xiao Ming"); // 设置name
        ming.setAge(12); // 设置age
        System.out.println(ming.getName() + ", " + ming.getAge());
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        if (age < 0 || age > 100) {
            throw new IllegalArgumentException("invalid age value");
        }
        this.age = age;
    }
}

• 调用方法setName()和setAge()来间接修改private字段，方法返回值通过return语句实现，如果没有返回值，返回类型设置为void，可以省略return。

private方法

public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        ming.setBirth(2008);
        System.out.println(ming.getAge());
    }
}

class Person {
    private String name;
    private int birth;

    public void setBirth(int birth) {
        this.birth = birth;
    }

    public int getAge() {
        return calcAge(2019); // 调用private方法
    }

    // private方法:
    private int calcAge(int currentYear) {
        return currentYear - this.birth;
    }
}

• calcAge()是一个private方法，外部代码无法调用，但是，内部方法getAge()可以调用它
• Person类只定义了birth字段，没有定义age字段，获取age时，通过方法getAge()返回的是一个实时计算的值，并非存储在某个字段的值

this变量

• 在方法内部，可以使用一个隐含的变量this，它始终指向当前实例，通过this.field就可以访问当前实例的字段，如果没有命名冲突，可以省略this

方法参数

• 方法可以包含0个或任意个参数。方法参数用于接收传递给方法的变量值。调用方法时，必须严格按照参数的定义一一传递

class Person {
    ...
    public void setNameAndAge(String name, int age) {
        ...
    }
}

• 调用这个setNameAndAge()方法时，必须有两个参数，且第一个参数必须为String，第二个参数必须为int

可变参数

• 可变参数用类型...定义，可变参数相当于数组类型

class Group {
    private String[] names;

    public void setNames(String... names) {
        this.names = names;
    }
}

• 上面的setNames()就定义了一个可变参数,完全可以把可变参数改写为String[]类型(需要自己先构造)

class Group {
    private String[] names;

    public void setNames(String[] names) {
        this.names = names;
    }
}

构造方法

默认构造方法

• 如果一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句

class Person {
    public Person() {
    }
}

• 没有在构造方法中初始化字段时，引用类型的字段默认是null，数值类型的字段用默认值，int类型默认值是0，布尔类型默认值是false：

在Java中，创建对象实例的时候，按照如下顺序进行初始化

class Person {
    private String name = "Unamed";
    private int age = 10;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

• 先初始化字段，例如，int age = 10;表示字段初始化为10，double salary;表示字段默认初始化为0，String name;表示引用类型字段默认初始化为null；
• 执行构造方法的代码进行初始化。

多构造方法

• 可以定义多个构造方法，在通过new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this.name = name;
        this.age = 12;
    }

    public Person() {
    }
}

• 如果调用new Person("Xiao Ming", 20);，会自动匹配到构造方法public Person(String, int)。
• 如果调用new Person("Xiao Ming");，会自动匹配到构造方法public Person(String)。
• 如果调用new Person();，会自动匹配到构造方法public Person()。

方法重载

• 在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

• 方法名相同，但各自的参数不同，称为方法重载Overload

学习java的第二周

原文：https://www.cnblogs.com/b1356436060/p/13377573.html