Java基础(三)--类和对象

发表于 | 分类于

快速入门

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.util.Scanner;

public class Cat {
    public static void main(String[] args) {
        CatItem[] cats = new CatItem[2];
        cats[0] = new CatItem("小黑",20);
        cats[1] = new CatItem("小白", 30);

        Scanner scanner = new Scanner(System.in);

        String find = scanner.next();
        scanner.close();

        for(int i = 0;i < cats.length;i++){
            if(find.equals(cats[i].GetName())){
                System.out.println(cats[i].GetAge());
            }
        }

    }
}

class CatItem {

    private String name;
    private int age;

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

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

    public void SetAge(int age){
        this.age = age;
    }

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

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

}

创建对象流程

  • 先加载类信息（属性和方法信息,只加载一次）
  • 在堆中分配对象空间，进行默认初始化（看规则），然后把对象地址赋值给栈中的变量

赋值和函数传递

  • 对象是引用类型，属于引用赋值和引用传递
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class MethodClass {
    
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "cjp";
        p.age = 23;

        MyTool tool = new MyTool();
        
        tool.ShowName(p);
        System.out.println(p.age); // 30

        tool.SetNull(p);
        System.out.println(p.age); // 30

        tool.NewObj(p);
        System.out.println(p.age); // 30
    }
}

class Person {
    String name;
    int age;
}

class MyTool {
    public void ShowName(Person p){
        // 直接修改的外部的p变量
        p.age = 30;
    }

    public void SetNull(Person p){
        //虽然person是引用传递但是设置的是方法内部的p变量和main中的p无关
        p = null;
    }

    public void NewObj(Person p){
        // 这时候p指向的是新开辟出来的对象和main中对象无关
        p = new Person();
        p.name = "gphper";
        p.age = 28;
    }
}

方法

1
2
3
4
5
访问修饰符 返回数据类型 方法名(形参列表...){
    //方法体
    语句;
    return 返回值;
}
  • void 表示没有返回值

重载

相同的方法名不同的形参列表

  • 满足条件
    • 方法名：必须相同
    • 形参列表： 必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）
    • 返回类型：无要求
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class OverLoad {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.print(32);
        demo.print("string show");
    }
}

class Demo{
    public void print(String s){
        System.out.println(s);
    }

    public void print(int i){
        System.out.println(i);
    }
}

可变参数

  • 注意事项
    • 可变参数的实参可以为0个或任意多个
    • 可变参数的实参可以为数组
    • 可变参数的本质就是数组
    • 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    • 一个形参列表中只能出现一个可变参数
1
2
3
4
5
6
7
8
9
10
11
12
public class VarParam {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.print(1,2,3,4,5);
    }
}

class Demo {
    public void print(int... args){
        System.out.println(args.length);
    }
}

构造器

  • 注意
    • 构造器没有返回值，也不能写void
    • 构造器的名称必须和类名一样
    • 构造器可以进行重载
    • 构造器是完成对象的初始化，并不是创建对象，new还是创建对象
    • 构造器只能是创建对象时系统自动调用，不能时使用对象显示调用
    • 如果程序员没有定义构造器，系统会自动给类生成一个默认无参的构造器(也叫默认构造器)，一旦定义了自己的构造器，默认的构造器就覆盖了，就不能使用默认的无参数构造器，除非显示的定义一下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Construct {
    public static void main(String[] args) {
        Persons p = new Persons("hello", 20);
    }
}

class Persons {
    String name;
    int age;

    public Persons(String uname,int uage){
        name = uname;
        age = uage;
    }
}

this的用法

代表的被调用对象

  • 注意事项
    • 放问成员方法的语法：this.方法名(参数列表)
    • 访问构造器语法：this(参数列表)；注意只能在构造器中使用
    • this不能在类定义的外部使用，只能在类定义的方法中使用