Java学习笔记01

发表于 | 分类于 | 评论数：

到底学个啥啊~

Java肯定是要学的，一门如此优秀的面向对象语言，使用范围也很广很广，学校还没开课，先当预习一下。至于有同学说，你这又是学C/C++，又是学Python，现在又搞一个Java，你是要上天呀，学这么多又学的浅有什么用吗？霍霍，肿么没用了？C/C++适合刷题，Python只是最近在弄爬虫这块，好歹也写了几个实用的爬虫出来了。至于Java呢？到目前我想不到对我有什么实际的用处，我尝试去刷题，但是不是很习惯，比如字符串处理，在C++中用String定义一个字符串，它可以直接当作数组来用，而Java似乎不能这样做…各种方法各种类有点难记。另外Java也可以写爬虫，但还没有学那么深，就不想那么多了。

我在B站学Java，推荐尚学堂Java 300集。其实看书也听实在的，但是有一个人讲肯定是更加容易理解一些的（当然，排除念PPT的老师…），想起来在B站看过不少的视频了…此乃真学习网站，谁说Bilibili不好我和谁急了。此外，由于Java本就是基于C语言开发的，所以面向过程的东西我大概都选择性跳过了，感觉问题不是很大…好吧，从面向对象开始吧，万物皆对象。

类与对象的概念

在生活中随处可见的有男生和女生，其“男”和“女”便是类，而说到某一个人，人们总会想到她是一个女生（属于女生这个类），同时她的名字、年龄、身高等等（对象的属性）。也就是每一个人都是独一无二的对象，这便是生活中的类与对象…

在Java中其实没太大的区别，比如下段代码中首先是导入了一个包，其中有一个public修饰的类Stu01，这便是java中的类。而ob01就是Stu01的实例，也就是对象。类的实例化可以引用类的属性和方法。

类可以看成是创建对象的模板。
对象可以看作类的实例化

上面说的呢？其实也就是一种造车，我有一张图纸（类），我根据这张图纸造了一辆车（对象）…对象有自己的属性和行为（方法），其实Java的类就好比C语言中的结构体的升级版…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Study01 {
    String name;
    String sex;
    int age;

    void play() {
        System.out.println("来一起玩耍吧~");
    }

    public static void main(String[] args) {
        Study01 ob01 = new Study01();
        ob01.name = "天天";
        ob01.sex = "男";
        ob01.age = 18;
        ob01.play();
    }
}

什么是方法？

类是方法和属性的集合，至于属性不就是在类里面定义的成员变量吗？那方法呢？方法是什么？方法有什么要点呢？

先看方法的概念：Java方法是语句的集合，它们在一起执行一个功能。
这不就是C语言中的函数吗？

再看方法的定义：

1
2
3
4
5
6
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

等等，这就是C语言的函数！！！

其实，Java的方法和C语言的函数很相似，只不过C语言的函数定义没有修饰符一说。
规则：方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson
另外类的名字应该以大小字母开头，好吧，这写规则在学C语言的时候没听到过，这里还是记住为好，代码规范很重要。

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
public class Study02 {
    public void play() {
        System.out.println("来一起玩耍吧~");
    }

    private int getMaxNum(int a, int b) {
        return a > b ? a : b;
    }

    protected double getArea(int r) {
        return 3.14 * r * r;
    }

    static void study() {
        System.out.println("来一起学习吧~");
    }

    public static void main(String[] args) {
        // play();     //运行报错
        study();    //可以直接使用static修饰的方法

        Study02 ob01 = new Study02();
        int MaxNum = ob01.getMaxNum(3, 4);
        double Area = ob01.getArea(4);
        System.out.println(MaxNum);
        System.out.println(Area);
        ob01.study();
        ob01.play();
    }
}

上面给出了四个方法，分别用public private protected static修饰，其中static修饰的方法可以不用实例化就能激活的方法。就好比咱们在C语言中写完主函数之后又写了一个自定义函数，我们可以在主函数或者其他函数中来调用这个函数。而其他三个方法需要实例化才能激活，也就是说咱们要先有对象才能有行为…就是这个样子了。

构造方法

构造方法也称构造器，它本质上还是一个方法，构造方法就是用来new对象的。
每一个Java程序都有构造方法，像前面那个程序没写构造方法，但是JVM会自动生成一个空构造方法。其实构造方法和普通方法的区别只是在于构造方法没有返回值，它的名字和类名一样，它的作用是构建对象。

方法的重载（Overload)

Java中同名的方法可以有多个，只要参数不一样就好了，Java会自动判断用哪个方法。比如下面的程序，它有两个构造方法Study03()，还有两个test()方法，在新建那两个对象的时候可以看到，我们给a和b赋值是不一样的，第一个是用的空构造方法，第二个是带参数的构造方法，可以看到第二种会更加简便，所以我们一般都会自己写构造方法，而不是用空构造方法。其中的this是代指这个对象，就是说this就代表的ob02。

同样的调用test()方法的时候，加了参数和不加参数的结果完全不一样，说明那是不同的两个方法。其实在使用out对象的方法的时候，它有很多选择，在其中可以发现有许多许多print()方法，只是参数不一样，可见重载还是挺常见的。

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
public class Study03 {
    int a, b;
    public Study03() {
    }

    public Study03(int a, int b) {
        this.a = a;
        this.b = b;
    }

    public void test(int n) {
        System.out.println("给我传值干嘛" + n);
    }

    public void test() {
        System.out.println("测试~");
    }

    public static void main(String[] args) {
        Study03 ob01 = new Study03();
        ob01.a = 12;
        ob01.b = 13;

        Study03 ob02 = new Study03(15, 16);

        ob01.test();
        ob01.test(100);

        ob02.test();
        ob01.test(999);
    }
}

对象创建的过程

构造方法是创建Java对象的重要途径，通过new关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造方法负责创建。创建一个对象分为如下四步：
1.分配对象空间，并将对象成员变量初始化为0或空
2.执行属性值的显示初始化
3.执行构造方法
4.返回对象的地址给相关的变量

this的本质

this的本质就是创建好的对象的地址，由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表当前对象。

this最常的用法：
1.在程序中产生二义性之处，应使用this来指明当前对象；普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
2.使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一行。

this不能用于static方法中

使用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
29
30
31
32
33
34
35
36
37
38
public class Study07 {
    int id;
    String name;

    //构造方法重载
    public Study07(String name) {
        //在调用构造方法之前对象实际上已经创建好了，this代指这个对象
        System.out.println("当前对象地址: " + this + "\n");

         //该方法局部变量和该类的成员变量名相同，用this.属性来代指
        this.name = name;
    }
    public Study07(int id, String name) {

        //用this()调用构造方法，必须在第一行
        this(name);
        //在调用构造方法之前对象实际上已经创建好了，this代指这个对象
        System.out.println("当前对象地址: " + this + "\n");
        this.id = id;
    }

    public void check() {
        //这里，当一个对象调用这个方法是，实质上对象已经确定（对象是类的实例化）
        System.out.println("当前对象地址: " + this);
        //实质上id是指实例化的属性（也就是对象）
        System.out.println("用户: " + id);
        System.out.println("用户: " + this.id);
    }

    public static void main(String[] args) {
    Study07 user01 = new Study07(101, "序曲");
        System.out.println(user01.name);
        user01.check();

        // this关键字不能用于静态方法中
        // System.out.println(this.name);
    }
}

static关键字

在类中，用static声明的成员变量为静态成员变量，也称为类变量。 类变量的生命周期和类相同，在整个应用程序执行期间都有效。它有如下特点：

1.为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
2.对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享!!
3.一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)
4.在static方法中不可直接访问非static的成员。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Test {
    static int a;
    public int b;

    //静态方法
    public static void main() {
        //不需实例化即可使用静态属性
        a = 0;
        Test.a = 0;

        //必须实例化才能使用
        Test obj01 = new Test();
        obj01.b = 6;
        // 此时obj01.a == 0

        Test obj02 = new Test();
        obj02.b = 60;
        obj02.a = 6000;

        //此时a == Test.a == obj01.a == obj02.b == 6000
        //如C语言中的全局变量，牵一发动全身，其它对象的该属性也会被更改
        //静态属性（a）从属于类，成员变量（b）从属于对象
    }
}