1. Java程序结构

public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello Java!!");
    }
}

将前面，我们写的Hello World程序，先分析一下：

为什么这样写，编译运行后就能打印Hello Java!! 呢？

Java程序是随便怎么写就行吗？

很明显，Java程序肯定不是随随便便，想怎么写就怎么写的，一定要遵循一定的规则。

上面的例子中有以下一些语法规则:

1. public: 访问修饰符，写在class前面表示class是公开的，写在方法前面表示方法是公开访问的
2. class: 定义类，类是程序的基本单位
3. Hello：自定义的类名，这个随我们自行定义，但必须大写字母开头
4. main：方法名，方法后面要加括号，括号中String[] args 代表方法的参数是 args，参数的类型是String[]
5. static: 一个修饰符，它表示静态方法
6. 文件名为Hello.java，后缀必须为.java，文件名必须和类名相同

Java入口程序规定的方法必须是静态方法，方法名必须为main，括号内的参数必须是String数组。

接下来，我们就来学习这些规则，只有符合规则，计算机（JVM）才能识别我们的程序

2. 基本语法

基本语法，必须牢牢记住，并且遵循，不要另辟蹊径，不要随心所欲，养成良好的编程习惯，这至关重要

• 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 Hello ，UserInfo。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写，例如：eat() , readBook()。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。
• 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
• 结束：Java每一行代码，都需要分号 ; 结尾。

Java中没有用_下划线命名的习惯，虽然语法不报错，但不建议

2.1 关键字

Java语法中会使用一些单词来表示特定的意义，比如class代表类，for代表循环等，这些单词称为是关键字。

Java语法检测会检测这些关键字，所以我们给常量，变量，方法，类起名的时候，不能用这些关键字，切记！！

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非Java实现）
	new	创建 实例化
	static	静态
	strictfp	精准浮点
	synchronized	同步
	transient	临时（不需要序列化）
	volatile	指令关键字，确保指令不失且读取新值
程序控制语句	break	跳出循环
	case	定义一个值以供switch选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
	null	空
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用

2.2 基本数据类型

从计算机诞生之初，目的就是为了做计算。什么是计算呢？1+1=2 ，这就是计算，我们知道数字有长有短，甚至无穷大或者无穷小，有的有小数点，有的没有，比如整数和小数。

计算机在进行计算的时候，必须要能够识别这些数字才行，同时我们还有中文，英文字母甚至是其他语言，这些计算机也都需要识别。

Java语言规定了一些数据类型，用以标识字母，数字等，通过这些数据类型，我们才可以做到计算或者更为复杂的操作。

Java中提供了8种基本数据类型：

• 4个 整数型：byte、short、int、long
• 2个浮点型：float、double
• 1个字符类型：char
• 1个布尔型：boolean

基本数据类型	默认值	大小（字节）	取值范围	示例
byte	0	1	-2^7—2^7-1	byte a=10;
boolean	false	1	true\false	boolean a=true;
char	'\u0000'	2	0—2^16-1	char a='c';
short	0	2	-2^15—2^15-1	short a=10;
int	0	4	-2^31—2^31-1	int a=1;
long	0	8	-2^63—2^63-1	long a=1L;
float	0.0f	4	-2^31—2^31-1	float a=1.0F;
double	0.0d	8	-2^63—2^63-1	double a=1.0;

2.3 大小说明

计算机内存的最小存储单元是字节(byte)，一个字节等于8bit，范围 0000 0000 - 1111 1111 ，这我们常说的计算机底层就是0和1，因为所有的数据都要换算为bit，计算机才能识别。

范围用十进制表示：0-255，用十六进制表示：00-ff

1GB = 1024MB 1MB = 1024KB 1KB = 1024B，1B=8bit ，B就是Byte 字节

2.4 类型转换

数据类型之间可以转换，高精度类型向低精度类型转换，可能会丢失精度，低精度和高精度计算会自动转换为高精度

精度从低到高排列：

byte short int long float double

    	//低精度和高精度运算
		long a = 1L;
        double b = 3d;
        double x = a * b;
        System.out.println(x);

//高精度转低精度 需要强转 强转会丢失精度，比如long 可以存2^63-1，但是int只能存2^31-1，存不下那么大的数据，多余的数据 就会丢失
double x = 1.7;
int y =(int) x; //当然 long y = (long) x 也是一样的道理;
//打印语句
System.out.println(y); // 1

2.5 String

Java 提供了 String 类来创建和操作字符串。

创建字符串最简单的方式如下:

String str = "码神之路";

用构造函数创建字符串：

String str2=new String("码神之路");

3. 详解Java程序的结构

3.1 类

Java是面向对象的语言，一个程序的基本单位就是class，class是关键字

一个类可以理解为一个文件。

而我们常说的对象就是类的一个实例。

public class Person { //public 修饰的类只能有一个，且要和文件名相同
}

类的实例化：

Person person = new Person();

3.2 方法

一个类可以有多个方法，方法可以理解为行为。

比如定义一个类Pen，笔能干什么？

最主要的一个用途肯定是写字了，所以write()是Pen的一个方法

笔还能干什么？画画，所以draw()也可以是Pen的一个方法

方法定义：

public class Pen {
    //没有返回值方法
    public void write() {  
        System.out.println("我可以写字");
    }
    //有返回值方法
    public int draw() { 
        System.out.println("我可以画画");
        return 1;
    }
    //静态、带参数，无返回值方法
    public static void drawLine(int x, int y) { 
        System.out.println(x+","+y);
        System.out.println("根据输入信息，我可以画一条线");
    }
    //静态、带参数，有返回值方法
    public static String drawCricle(String input) { 
        System.out.println(input);
        return "我画了一个圆"
    }
}

方法的定义：

• 用{} 表示方法的起始。
• 方法可以自定义参数、返回值。
• void 表示方法没有返回值。
• 参数写在方法名后面的括号里。
• 返回值写在方法名的左边
• 返回值左边 可以加一些修饰符，比如public（访问修饰符）static（静态修饰符）

方法的调用：

public static void main(String[] args) {
    Pen pen = new Pen(); //实例化
    pen.write(); //方法的调用
    System.out.println(pen.draw());
    //静态方法调用
    Pen.drawLine(10,20);
}

3.3 变量

Java语言变量的特点就是 先定义，再输出。

Java语言支持的变量类型有：

1. 类变量(静态变量)：独立于方法之外的变量，用 static 修饰。
2. 实例变量：独立于方法之外的变量，不过没有 static 修饰。
3. 局部变量：类的方法中的变量。

局部变量必须初始化才能使用

public class Hello {
    
    static int sex = 0; //类变量
    int age; //定义一个age的实例变量
    public static void printName() {
        String name = "mszlu"; //定义一个name的局部变量，必须初始化才能使用
        System.out.println(name); 
        System.out.println(age);  //使用实例变量
         System.out.println(sex);  //使用类变量
    }
}

我们把类变量和实例变量，称为成员变量

普通方法可以调用成员变量，方法不能使用其他方法的局部变量。(局部变量就是说是方法私有的)

3.4 包

package，用于区别类名的命名空间。

作用：

1. 功能相似的类放在一个包下。
2. 相同包下的类名不能相同，不同包下的类名可以相同。
3. 包有访问权限，拥有包访问权限的类才能访问包中的类。

如果要引用其他类，就可以使用 import 在程序的头部导入

package 、import 在类的头部 声明

package com.mszlu.hello;  //声明在哪个包
import com.alibaba.fastjson.JSON; //我需要引用的外部类

public class Hello {
}

3.5 修饰符

修饰符分为两种：

• 访问修饰符
• 非访问修饰符

3.5.1 访问修饰符

有时候我们希望变量、方法、类 不允许给外部、其他方法 访问，我们可以使用访问修饰符

修饰词	本类	同一个包的类	继承类	其他类
public	√	√	√	√
protected	√	√	√	×
default（无，默认）	√	√	×	×
private	√	×	×	×

public class HelloMszlu { //public 声明类
    private String name = "码神之路"; //private 声明变量
    protected void printName(){ //protected 声明方法
        System.out.println(name);
    }
}

3.5.2 非访问修饰符

3.5.2.1 static 修饰符

static 修饰符，可以用来修饰类方法和类变量，用static修饰的方法叫 静态方法 ，修饰的代码块叫静态代码块，修饰的变量叫静态变量

• 静态变量

无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。

局部变量不能被声明为 static 变量。

• 静态方法

静态方法不能使用类的非静态变量

非静态变量则可以使用静态方法

• 静态代码块

静态代码块的执行在方法初始化前就会执行，代码中一般很少用到。

对类变量和方法的访问可以直接使用 类名.方法名 ，类名.变量名 直接访问

public class HelloMszlu {
    static String name = "码神之路"; //静态变量

    static   //静态代码块
    {
        System.out.println(name);
    }

    //静态方法
    public static void printName(){
        System.out.println(name);
    }
}

3.5.2.2 final 修饰符

####### final变量

final的意思是最终的，变量一旦被final修饰，就必须初始化，且不能被重新赋值，一般配合 static 使用。

所以被final修饰的又叫做常量。

public class HelloMszlu {
    static final String WEIXIN_ID = "god_coder";
    public static void main(String[] args) {
        WEIXIN_ID = "码神之路"; //重新赋值，报错
    }
}

final 什么时候使用呢？

当一个变量你不想让它修改的时候，就可以用final来修饰(要注意，不是修饰了就不能修改)

package com.mszlu.alg.divide;

public class HelloMszlu {
    static final String WEIXIN_ID = "god_coder";
    static final String[] names = {"B站：码神之路","抖音：码神之路"};
    public static void main(String[] args) {
//        WEIXIN_ID = "码神之路"; //重新赋值，报错
        names[1] = "公号：码神之路";
        System.out.println(names[1]);
    }
}

####### final 方法

父类中的 final 方法可以被子类继承，但是不能被子类重写。后面讲继承的时候，在演示

4. 组合

新建一个HelloMszlu的类，把以上所学的融合到一个类中：

package com.mszlu.hello;

public class Hello {
    static int age; //全局变量、类变量
    private static String name ; //静态变量，没有初始化值
    static final String B_ACCOUNT = "码神之路";

    public static void main(String[] args) {
        Hello.printName();  //static 的方法可以直接使用 类名.方法名 调用
        printSex(); // 同一个类的static方法 则 可以直接调用
    }

    private static void printName() {  //private static 方法
        System.out.println(name);  //static方法调用的方法、变量必须也是static的
        System.out.println(age);  //static方法调用的方法、变量必须也是static的
        System.out.println(B_ACCOUNT); 
    }

    private static void printSex() {
        String sex = "男";
        System.out.println(sex); //局部变量sex要想使用，必须初始化
    }
}

Java规定，某个类定义的public static void main(String[] args)是Java程序的固定入口方法，因此，Java程序总是从main方法开始执行

输出：

null
0
码神之路
男

main方法的入口调用了两个方法printName()和printSex()

printName() 方法输出类变量age、name的值，因为没有初始化，所以会输出默认值 0 和 null