重学面向对象-基础篇01类与对象

类与对象

基础概念

类：一类事物，比较概括性（动物）

对象：类的实例，具体的某样事物（猫）

属性：类的成员变量，表示某事物所具有的特征（性别）

方法：对象可以做出的一些行为，是语句的集合，为了完成某件事情而存在（抓老鼠）

方法定义时编写的参数，我们一般称为形式参数，而调用方法实际传入的参数，我们称为实际参数。

静态变量：静态的内容，我们可以理解为是属于这个类的，也可以理解为是所有对象共享的内容。我们通过使用static关键字来声明一个变量或一个方法为静态的，一旦被声明为静态，那么通过这个类创建的所有对象，操作的都是同一个目标，也就是说，对象再多，也只有这一个静态的变量或方法。一个对象改变了静态变量的值，那么其他的对象读取的就是被改变的值。

代码实现

创建类->定义类->创建对象

public class Person {
    String name;
    int age;
    String sex;
}

public class Main {
    public static void main(String[] args) {
        new Person();
    }
}

使用对象

public class Main {
    public static void main(String[] args) {
        new Person();
        Person p1 = new Person();
        //此处p1存放的是对象的引用，而非本体，可通过对象的引用来间接操作对象
        Person p2 = p1;
        //p2赋值p1，仅传递对象的引用，而非对象的复制，p1和p2指向同一对象
        System.out.println(p1 == p2);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "Alice"; //访问对象的属性，需要使用.运算符
        System.out.println(p.name);
    }
}

Alice

public static void main(String[] args) {
    Person p = null; //null是一个特殊的值，它表示空，也就是不引用任何的对象
    p.name = "小红"; //我任性，就是要操作
    System.out.println(p.name);
}

空指针异常:操作一个值为null的变量导致出现错误

public static void main(String[] args) {
    Person p = new Person();
    System.out.println("name = "+p.name);
    System.out.println("age = "+p.age);
    System.out.println("sex = "+p.sex);
}

//直接创建对象，那么对象的属性都会存在初始值，如果是基本类型，那么默认是统一为0（如果是boolean的话，默认值为false）如果是引用类型，那么默认是null

方法的调用

public class Person {
    String name;
    int age;
    String sex;

    void hello(){
        System.out.println("我叫 "+name+" 今年 "+age+" 岁了！");
    }

    int sum(int a, int b){
        int c = a + b;
        return c;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "Alice"; //访问对象的属性，需要使用.运算符
        p.age = 21;
        int result = p.sum(10,20);
        System.out.println(result);
        p.hello(); //只需要使用.运算符，就可以执行定义好的方法
    }
}

30
我叫 Alice 今年 21 岁了！

方法进阶使用

//在方法中访问到当前对象的属性，那么可以使用this关键字，来明确表示当前类的示例对象本身
void setName(String name){
        this.name = name; //让当前对象的name变量值等于参数传入的值
    }

//如果方法内没有变量出现重名的情况，那么默认情况下可以不使用this关键字来明确表示当前对象
String getName(){
        return name; //没有使用this，但是当前作用域下只有对象属性的name变量，所以说直接就使用了
    }

方法的重载

//一个类中可以包含多个同名的方法，但是需要的形式参数不一样，方法的返回类型，可以相同，也可以不同，但是仅返回类型不同，是不允许的！
int sum(int a,int b) {
    return a + b;
}
double sum(double a,double b) {
    return a + b;
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.sum(1,2));
        System.out.println(p.sum(1.2,1));
    }
}

3
2.2

递归调用

void test(){
    test();
}

//计算从1加到n的和
int test(int n){
    if(n == 0) return 0;
    return test(n - 1) + n; //返回的结果是下一层返回的结果+当前这一层的n
}

构造方法

//要在对象创建时进行处理，我们可以使用构造方法（构造器）来完成
public class Person {
    String name;
    int age;
    String sex;

    Person() { //构造方法不需要指定返回值，并且方法名称与类名相同
        name = "小明"; //构造方法会在对象创建时执行，我们可以将各种需要初始化的操作都在这里进行处理
        age = 18;
        sex = "男";
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person(); //调用无参构造方法
        System.out.println(p.name);
    }
}

小明

//在我们自己定义一个构造方法之后，会覆盖掉默认的那一个无参构造方法，除非我们手动重载一个无参构造，否则要创建这个类的对象，必须调用我们自己定义的构造方法
public class Person {
    String name;
    int age;
    String sex;

    Person() { //构造方法不需要指定返回值，并且方法名称与类名相同
        name = "小明"; //构造方法会在对象创建时执行，我们可以将各种需要初始化的操作都在这里进行处理
        age = 18;
        sex = "男";
    }

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

public class Main {
    public static void main(String[] args) {
        Person p = new Person("小明", 18, "男"); //调用自己定义的带三个参数的构造方法
        System.out.println(p.name);
    }
}

静态变量&静态方法

静态内容一定会在第一个对象初始化之前完成加载

//我们通过使用static关键字来声明一个变量或一个方法为静态的，一旦被声明为静态，那么通过这个类创建的所有对象，操作的都是同一个目标，也就是说，对象再多，也只有这一个静态的变量或方法。
public class Person {
    String name;
    int age;
    String sex;
    static String info;

    //静态代码块可以用于初始静态变量
    static {
        info = "Apple";
    }

    static void test(){
        //在静态方法中，无法使用this关键字，因为this关键字代表的是当前的对象本身
        System.out.println("我是静态方法");
        //静态方法可以访问到静态变量，在静态方法中，无法获取成员变量的值
        System.out.println("静态变量的值为:" +info);
    }
}

public class Main {
    public static void main(String[] args) {
        Person.info = "Hello World";
        System.out.println(Person.info);
        Person.test();
    }
}