ZB-005-JAVA基本结构

JAVA介绍

  1. 强类型
  2. 静态编译
  3. 跨平台

代码比较死板，但是非常适合团队协作项目。

什么是操作系统

比如现在有 windows / mac / linux 三个系统，你要让他们做什么比如 打开文件，发请求就要使用操作系统的语言(API)和操作系统对话

这样就给软件开发者开了一个很大的难题。你开发了一个软件跑在三个系统上。就要用三个系统的API去分别编写。此时工作量变成了三倍！

举个例子,比如你要写一本书，三个系统好比三个国家。

  • 你使用了某个语言如 英语 English
  • 此时需要去三个国家找到对应懂英语的人。
  • 这样你只要在每个国家找到懂英语的人。你本来是要为每个国家开发一本书。现在你只需要开发一本书，然后让不同平台懂英语的人翻译成对应国家的语言。

这个会翻译的人 在JAVA中就叫 JVM 虚拟机

JVM负责与操作系统的接口打交道，此时你只要写一种语言如java,剩下的交给JVM将 java翻译成中间层的语言 byte code(字节码)

字节码

二进制，在计算机里只有0和1

java广告词

java语言的基本单元 类 和 包

class

  • java最小的结构是 类
  • 类必须放在与它同名的 .java文件中
1
2
3
4
5
// 程序最小的结构是 class
// 直接放在 src/main/java下的包叫做 “默认包”
public class Cat{

}

package

  • 每个类都处在一个包中
  • 包的名字由目录结构所确定
1
2
3
4
5
// 目录结构为: src/main/java/my/cute
package my.cute;
public class Cat{
    
}
推荐包名规则
  • java程序约定(我不强制你这么做，但我约定你这么做)
1
2
3
4
5
6
# 不建议这样
package my.cute;

# java推荐约定  包名以你互联网公司域名的反序来命名，这样可以避免命名冲突
package com.alibaba
package com.google

maven的项目约定

1
2
3
4
5
// 生产代码
src/main/java/my/cute/Cat.java

// 测试代码
src/test/java/my/cute/CatTest.java

包的意义

如果存在如下两个同名的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
src/main/java/my/pet/Cat.java
src/main/java/my/pet2/Cat.java


// 如何在 src/main/java/my/Home.java里引用者两个 Cat呢？

// Home.java
package my;

import my.pet.Cat;
// import my.pet2.Cat; 

public class Home{
    Cat cat;
    //全限定类名
    my.pet2.Cat cat2;
}
  • 在JVM中所有的类 都会变成“全限定类名” Full Qualified Name (FQCN) 
    1
    2
    3
    4
    5
    public class Home{
        // 最终都会变成
        my.pet.Cat cat;
        my.pet2.Cat cat2;
    }

这就是为什么我们需要“包” 最大的作用就是避免命名冲突，区分同名但不同的类

main函数

1
2
3
4
5
6
public class Cat{
    // 程序的入口函数
    public static void main(String[] args){

    }
}
  • 疑问为什么String[] args 里的 String不用写包名 ，如果你用的是 IDEA按住 alt点击进去，发现 String的包名是 package java.lang
  • 如果你的类放在 java.lang 下 可以不经引入直接使用

方法调用

  • 在每个函数调用的时候，它会创建一个全新的函数的执行环境
  • 函数多次调用的过程之间，它们是相互独立的。
  • 函数可以被一次声明，然后多次调用，每次调用的执行环境都是独立的。
1
2
3
4
5
6
7
8
9
10
public class Cat{
    public static void main(String[] args){
        f(1);
        f(2);
    }

    public static void f(int i){
        return i + 1;
    }
}

局部变量

  • 包围它的第一对花括号{}

静态成员变量

存在遥远的jvm的一个地方，独立于任何的对象。和任何对象都没关系

1
2
3
4
5
6
7
8
9
10
11
12
public class Cat{
    public static int i; // 默认会初始化为0

    public static void main(String[] args){
        add();
        add();
    }

    public static void add(){
        i = i + 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
public class Home{
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.name = "阿三";
        cat.miao();

        Cat cat2 = new Cat("阿大");
        cat2.miao();

        Cat cat3 = new Cat();
        cat3.miao(); // 空指针 因为name是null
    }
}

class Cat{
    // 成员变量
    private String name;
    // 假如你没声明任何的构造器 ,编译器会帮你偷偷生产一个构造器
    //  Cat(){} // 你不写就自带一个

    public Cat(){}
    // 如果你写了其他构造器，将不再提供默认的无参构造器，而你想调用无参的构造器则要自己写。
    public Cat(String name){
        // this = 刚刚创建的Cat类的实例
        this.name = name;
    }
    /*
    public static void miao(){
        // 报错，静态方法不能调用非静态成员
        System.out.println("喵,我是"+ name)
    }
    */

    public void miao(){
        System.out.println("喵,我是"+ name)
        // 在不引起歧义的情况下，你可以 省略 this
        System.out.println("喵,我是"+ this.name + "我的名字长度是" + name.length());
    }
}

实例方法和空指针异常

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 Home{
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.name = "阿三";
        cat.miao();

        Cat cat2 = new Cat("阿大");
        cat2.miao();

        Cat cat3 = new Cat();
        cat3.miao(); // 空指针 因为name是null
    }
}

class Cat{
    String name;
    public Cat(){}
    public Cat(String name){
        this.name = name;
    }

    public void miao(){
        // 非空判断 ，规避空指针
        if(name == null){
            System.out.println("我还没名字");
        }else{
            System.out.println("喵,我是"+ this.name + "我的名字长度是" + name.length());
        }
    }
}

对象和引用、值传递