Java面向对象基础

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 2.1k | 阅读时长 ≈ 8
Java面向对象基础

2

Java面向对象基础

  面向对象的编程思想(Object Oriented Programming, OOP)是程序设计发展的必然阶段，在70年代初，人们使用面向过程的编程思想解决问题，但是随着时代的进步，人们发现这种编程思想非常繁琐，尤其是定义多个相同或相似的变量，需要进行非常冗余的代码编写。这就引入了OOP的观念，面向对象的思想是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
//定义类时，需要使用public + class关键字 + 类名，然后在花括号中定义成员变量和成员方法。
//这种将成员变量和成员方法写在一个类中，创建对象时，所有对象都具有这些成员变量，也可以使用成员方法，这种思想称为封装。
//要注意的是在Java中每一个类就是一个单独的文件，因此我们不能把多个类写入同一个.java文件中。
//导包是一个非常重要的工具，当我们要使用其他开发者定义的类时，我们就需要导包，如果要使用的类和本类在同一个包下，可以省略导包语句，否则需要import 包名.类名进行导入才可以使用。
package demo01;

public class Person {
    String name;
    int age;

    public void eat() {
        System.out.println("I am hungry!");
    }

    public void sleep() {
        System.out.println("I am sleepy!");
    }
}
	
package demo01;

public class Oop1 {
    public static void main(String[] args) {
        //对象的创建，可以通过类名 变量名 = new 类名(参数列表)进行创建，和C++不同的是如果没有参数也不能省略括号。
        Person p1 = new Person();
        //对象的使用，如果想访问对象的成员变量或者成员方法和结构体相同，使用小数点进行访问。
        p1.name = "睡神";
        p1.age = 24;
        System.out.println("我的名字是：" + p1.name);
        System.out.println("我的年龄是：" + p1.age);
        p1.eat();
        p1.sleep();
    }
}

1

构造函数

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
package demo01;

public class Person {
    String name = "xxx";
    int age = 0;

    //构造函数是和类名同名的一种特殊的成员函数，当创建对象时会自动调用类的构造函数。
    //如果没有自定义构造函数，编译器会自动帮你创建一个无参的构造函数，里面是空实现，如果自定义了构造函数，则编译器不会再帮你创建无参构造函数。
    //构造函数的出现帮我们省去了每个成员变量重新赋值的操作，而且构造函数可以发生函数重载。
    //注意构造函数的写法，没有返回值。
    //和C++不同的地方还在于Java中存在GC垃圾回收机制，不需要程序员进行手动清理，因此没有析构函数，关于GC会在以后的课程中进行相关的介绍。
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("我是" + this.name + "我有两个参数的构造函数，我被执行了~");
    }

    public Person(String name) {
        this.name = name;
        System.out.println("我是" + this.name + "我有一个参数的构造函数，我被执行了~");
    }

    public Person() {
        System.out.println("我是" + this.name + "无参的构造函数，我被执行了~");
    }
}

package demo01;

public class Oop1 {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person("婴儿");
        Person p3 = new Person("程序员", 24);

        System.out.println(p1.name + "的年龄是：" + p1.age);
        System.out.println(p2.name + "的年龄是：" + p2.age);
        System.out.println(p3.name + "的年龄是：" + p3.age);
    }
}

2

拷贝构造函数

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
package demo01;

public class Person {
    String name = "xxx";
    int age = 0;
    int[] score;

    public Person(String name, int age, int[] score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("我是" + this.name + "我有三个参数的构造函数，我被执行了~");
    }

    //拷贝构造函数的参数是一个同类型的对象，可以根据传入的对象创建一个相同的对象。
    //与C++不同的是，默认情况下编译器不会提供拷贝构造函数，需要程序员自己定义。
    public Person(Person p) {
        this.name = p.name;
        this.age = p.age;
        this.score = p.score;
        System.out.println("我是" + this.name + "拷贝构造函数，我被执行了~");
    }
}

package demo01;

public class Oop1 {
    public static void main(String[] args) {
        Person p1 = new Person("程序员1", 24, new int[]{80});
        Person p2 = new Person(p1);
        p2.name = "程序员2";
        System.out.println("程序员1的成绩为：" + p1.score[0]);
        System.out.println("程序员2的成绩为：" + p2.score[0]);
        p1.score[0] = 90;
        System.out.println("程序员1的成绩为：" + p1.score[0]);
        System.out.println("程序员2的成绩为：" + p2.score[0]);
    }
}

2

深拷贝和浅拷贝

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
package demo01;

public class Person {
    String name = "xxx";
    int age = 0;
    int[] score;

    public Person(String name, int age, int[] score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("我是" + this.name + "我有三个参数的构造函数，我被执行了~");
    }
    //深拷贝：指当对象或者变量复制时，不是简单的赋值操作，而是内存的重新分配，即两个对象或者变量中的地址是不重复的。修改了原对象，拷贝构造对象不会发生改变。
    //浅拷贝：指当对象或者变量复制时，通过简单的赋值号，完成拷贝，两个对象或者变量可能指向同一块内存地址。修改了原对象，拷贝构造对象也会发生改变。
    //在上面的例子中使用的是浅拷贝，因此修改了程序员1的成绩，程序员2的成绩也会发生改变。因为两个程序员的成员变量指向了同一块内存地址。在本例中重新进行了内存的申请，两个成员变量的地址是不同的。
    public Person(Person p) {
        this.name = p.name;
        this.age = p.age;
        this.score = new int[1];
        this.score[0] = p.score[0];
        System.out.println("我是" + this.name + "拷贝构造函数，我被执行了~");
    }
}

package demo01;

public class Oop1 {
    public static void main(String[] args) {
        Person p1 = new Person("程序员1", 24, new int[]{80});
        Person p2 = new Person(p1);
        p2.name = "程序员2";
        System.out.println("程序员1的成绩为：" + p1.score[0]);
        System.out.println("程序员2的成绩为：" + p2.score[0]);
        p1.score[0] = 90;
        System.out.println("程序员1的成绩为：" + p1.score[0]);
        System.out.println("程序员2的成绩为：" + p2.score[0]);
    }
}

2

this指针

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
package demo01;

public class Person {
    String name = "xxx";
    int age = 0;
    //this指针是隐含在每一个非静态成员函数中的一个指针，使用时无需定义，指代当前对象，其本质是一个指针常量，指针的指向是该对象，不可以修改，但是指针指向的值可以修改。
    //this指针的作用是指代该对象的成员变量或者成员函数，在构造函数中常有体现，当进行赋值时，由于作用域的原因，参数列表中的参数如果和成员变量同名，则会隐藏成员函数，如果想访问可以通过this指针。
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("我是" + this.name + "我有两个参数的构造函数，我被执行了~");
    }

    //当要返回当前对象时，可以使用return this，返回值仍是一个对象，因此还可以继续调用成员变量或者成员方法，体现出链式编程的思想。
    public Person print() {
        System.out.println("我被执行了~");
        return this;
    }
}

package demo01;

public class Oop1 {
    public static void main(String[] args) {
        Person p = new Person("程序员", 24);
        p.print().print().print();
    }
}

2

Java小结

  在这里给小伙伴们介绍了Java的基本面向对象的概念，虽然不是很难，但是非常重要，在这里为了方便起见，使用了public关键字，下一节会为大家详细介绍几种访问权限关键字。

-------------本文结束感谢您的阅读-------------
0%