public class HelloWorld{ //类体开始
    //public：公开的
    //class：一个类
    //HelloWorld：类名
    //表示一个共有的类HelloWorld

    public static void main(String[] args){ //方法体开始
        //整个这一块的代码被称为：main方法（程序的入口，sUN公司java语言规定的）
        //也就是说：JVM在执行程序的时候，会主动去找这样一个方法。没有这个规格的方法，程序不能执行
        //main方法也可以叫做主方法。
        //注意：方法必须放到类体中，不能放到类体外面。
        System.out.print("Hello "); //作用：向控制台输出一句话
        //如果println里面的事字符串，就应该用英文创引号括起来
        //
        System.out.println("World!");
    } //方法体结束

}//类体结束

//----------------------------------------------------------------------

//以下程序可以编译通过，但是无法运行，符合语法规则。

public class Test2{
}

/*
>java Test2
错误: 在类 Test2 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
*/

//---------------------------------------------------------------------

/*
没有语法错误，没有入口，能够编译通过，但是不能运行，因为没有main方法。

错误: 在类 Test3 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
*/
public class Test3{
    static void main(String[] args){
    
    }
}

//---------------------------------------------------------------------

public class Test4{
	// 注意：args可以改名字，随意，对于主方法来说只有这个位置可以改，其它位置不能动
	public static void main(String[] fdsafdsafdsafdsa){
		System.out.println("hello world");
	}
}

//---------------------------------------------------------------------

// 以下程序符合java语法规则吗？不符合！
// 不是不运行，是编译报错。编译过不去，运行肯定不行。

public class Test5{

	// 类体当中应该是方法，而不是直接的java语句
	// 这里可以写吗？不可以！
	System.out.println("hello1");
	
	// 主方法，入口
	public static void main(String[] args){
	
	}

	// 这里可以写吗？不可以！
	System.out.println("hello2");
}

//---------------------------------------------------------------------

// main方法中什么也不写行吗？可以！
// 以下程序编译和运行可以吗？可以！
public class Test6{
	// 入口
	public static void main(String[] args){
	}
}

//---------------------------------------------------------------------

public class Test7{
	
	public static void main(String[] args){

		// 这个不加双引号行吗？ 可以，因为它是数字。
		System.out.println(100);

		// 是数字，加双引号行吗？
		System.out.println("100");

		// 以上性质一样吗？不一样：一个是字符串，一个是数字。
		// 但最终输出到控制台上一个样子，没啥区别。

		// 这里扩展一下：对于数字来说能进行加减乘除吗？
		// + - * / 能用吗 ？ 都可以！
		System.out.println(100 + 200); // 300
		System.out.println(200 - 100); // 100
		System.out.println(200 * 100); // 20000
		System.out.println(200 / 100); // 2
	}
}

class A{

}
class B{

}
class C{

}
class D{

} //编译成功并且生成了 四个类 A.class B.class C.class D.class
/*
	1、这个内容没有为什么，只能经过测试，然后根据测试结果进行记忆。

	2、第一个结论？
		一个java源文件中可以定义多个class。
	
	3、第二个结论？
		public的类不是必须的。可以没有。

	4、第三个结论？
		在源文件中只要有一个class的定义，那么必然会对应生成一个class文件。
	
	5、第四个结论？
		public的类可以没有，但如果有的话，public修饰的类名必须和源文件名保持一致。
	
	6、第五个结论？
		public的类有也只能有1个。
*/
class A{

}

/*
	Test8.java:20: 错误: 类 B 是公共的, 应在名为 B.java 的文件中声明
	public class B{
			 ^
	1 个错误
*/
/*
public class B{

}
*/

// 如果定义public的类你只能这样写
public class Test8{
}

class C{

}

class D{

}

//错误: 类重复: Test8
/*
public class Test8{
}
*/

//---------------------------------------------------------------------

// 编译通过了
// 能执行吗？
// 想从哪个入口进去执行，你就加载哪个类就行了！
// 例如：java T1
// 例如：java T2

// 测试不代表以后就这样写，一般一个软件的执行入口是一个。不会出现多个的。
// 以下只是一个测试罢了。
class T1{
	// 想从这个入口进去执行怎么办？java T1
	public static void main(String[] args){
		System.out.println("T1.....");
	}
}

class T2{
	// 想从这个入口进去执行怎么办？java T2
	public static void main(String[] args){
		System.out.println("T2.....");
	}
}

/**
javadoc注释：这里的注释信息可以自动被javadoc.exe命令解析提取并生成到帮助文档当中。
*/

public class BiaoShiFuTest{
	// main是一个方法的名称，属于标识符
	// 但是这个标识符不能修改，因为这个main是SUN固定死的。
	public static void main(String[] args){
	}

	//doSome是一个方法名，可以改成其他的名字
	public static void doSome(){
		// k是一个变量名
		int k = 100;
		// nianLing 是一个变量名
		int nianLing = 20;
	}
}

/*
	class 123ABC{
	}

*/

class Y123ABC{
}

class Hello World{
}

class Hello{
}

class HelloWorld                   {
}

class _A{
}

class _$1Aa你{
}

public class IdentifierTest{
	public static void main(String[] args){
		// 主要看两个汉语拼音，可读性很强。
		// nianLing和mingZi都是黑色字体的标识符。
		int nianLing = 20;
		String mingZi = "zhangsan";
	}
}

// 1. java中的变量必须先声明，再赋值才能访问（必须手动赋值。）
int k; 
System.out.println(k); //这样是不行的。

// 2. 可以在一行上声明多个变量：

int a, b, c = 100;
// c变量赋值100，a,b变量只声明了没有赋值。
int a = 10, b = 20, c = 100;
// 也可以这样每个都赋值。

// 3.声明和赋值可以分开，也可以一起做！

int i;
i = 100; // 先声明再赋值
int k = 200; // 声明的同时赋值

{
    int i = 100;
    //double i = 2.0; // 重名了编译器会报错，不允许。
    i = 300; // 可以重新赋值。
}

//在方法体当中声明的变量叫做局部变量。

public static void m1(){
//局部变量，方法执行结束之后内存释放。
    int k = 100;
    int i = 200;
}

//在方法体外以及类体内声明的变量叫做成员变量。
public class T{
public static void x(){

}
	// 成员变量
	int i = 200;
}

//变量的作用域
//出了大括号就不认识了。别的先别管。
{
	int i = 100;
	{
		//在这里可以访问i
	}
}
{
	//在这里是无法访问i变量。
}

public class VarTest08{

	// 成员变量
	int i = 10000;

	public static void main(String[] args){
		// 局部变量
		int i = 100; // 这个i的有效范围是main方法。
		System.out.println(i); // 这个i是多少？

		// 同一个域当中，这是不允许的。
		//int i = 90;  

		for(int n = 0; n < 10; n++){ // 这里声明的n变量只属于for域。for结束后n释放没了。
			// 这里没有编写代码。
		}

		// for循环执行结束之后，在这里访问n变量可以吗？
		//System.out.println(n);  //错误: 找不到符号

		int k; // 属于main域。
		for(k = 0; k < 10; k++){

		}
	}

	// 这个方法怎么定义先不用管，后面会学习。
	public static void x(){
		// 在这个位置上能访问i吗？不能
		// 错误: 找不到符号
		// System.out.println(i); // i是无法访问的。

		// 可以定义一个变量起名i吗？
		// 这个i的有效范围是x方法。
		// 局部变量
		int i = 200; // 所以这个i和main方法中的i不在同一个域当中。不冲突。
	}
}

public class CharTest01{
	public static void main(String[] args){
		// char可以存储1个汉字吗？
		// 可以的，汉字占用2个字节，java中的char类型占用2个字节，正好。
		char c1 = '中';
		System.out.println(c1);

		char c2 = 'a';
		System.out.println(c2);

		// 0如果加上单引号的话，0就不是数字0了，就是文字0，它是1个字符。
		char c3 = '0';
		System.out.println(c3);

		// 错误: 不兼容的类型: String无法转换为char
		//char c4 = "a";

		// 错误: 未结束的字符文字
		//char c5 = 'ab';

		// 错误: 未结束的字符文字
		//char c6 = '1.08';

	}
}

/*
	关于java中的转义字符
*/
public class CharTest02{
	public static void main(String[] args){


		System.out.println("s");
		// 编译报错。
		//System.out.println(""");
		//System.out.println("\"");

		// 这个可以输出吗？
		// 这个不需要专门进行转义。
		// 这个 ' 在这里只是一个普通的字符，不具备特殊含义。
		System.out.println("'");

		//以下都有问题
		//System.out.println(''');
		//System.out.println(""");

		// 可以的。
		System.out.println("'这样呢'");

		// 编译报错，因为：4e2d 是一个字符串
		// 错误: 未结束的字符文字
		//char x = '4e2d';

		// 反斜杠u表示后面的是一个字符的unicode编码。
		// unicode编码是十六进制的。
		char x = '\u4e2d';
		System.out.println(x); // '中'
	}
}

/*
	1、整数能否直接赋值给char
	2、char x = 97;
		这个java语句是允许的，并且输出的结果是'a'
		经过这个测试得出两个结论：
			第一个结论：当一个整数赋值给char类型变量的时候，会自动转换成char字符型，最终的结果是一个字符。

			第二个结论：当一个整数没有超出byte short char的取值范围的时候，
			这个整数可以直接赋值给byte short char类型的变量。
*/
public class CharTest03{
	public static void main(String[] args){
	
		char c1 = 'a';
		System.out.println(c1);

		// 这里会做类型转换吗？
		// 97是int类型（这是java中规定，默认当做int处理）
		// c2是char类型
		//char c2 = (char)97; // 不需要这样做。
		char c2 = 97;
		System.out.println(c2); // 'a'

		// char类型取值范围：[0~65535]
		char c3 = 65535; // 实际上最终是一个“看不懂”的字符。
		System.out.println(c3);

		//错误: 不兼容的类型: 从int转换到char可能会有损失
		//char c4 = 65536;

		// 怎么解决以上问题？
		char c4 = (char)65536;

		byte x = 1;
		short s = 1;
		char c = 1;

	}
}

/*
	开发的时候不用斤斤计较，直接选择使用int就行了。
*/
public class IntTest01{
	public static void main(String[] args){

		// 二进制（JDK8的新特性，低版本不支持。）
		int d = 0b10;
		System.out.println(d); // 2
	}
}

public class IntTest02{
	public static void main(String[] args){

		// 分析这个代码存在类型转换吗，以下代码什么意思？
		// 不存在类型转换
		// 100 这个字面量被当做int类型处理
		// a变量是int类型，所以不存在类型的转换。
		// int类型的字面量赋值给int类型的变量。
		int a = 100;
		System.out.println(a);

		// 分析这个程序是否存在类型转换？
		// 分析：200这个字面量默认被当做int类型来处理
		// b变量是long类型，int类型占4个字节，long类型占8个字节
		// 小容量可以自动转换成大容量，这种操作被称为：自动类型转换。
		long b = 200;
		System.out.println(b);

		// 分析这个是否存在类型转换？
		// 这个不存在类型转换。
		// 在整数型字面量300后面添加一个L之后，300L联合起来就是一个long类型的字面量
		// c变量是long类型，long类型赋值给long类型不存在类型转换。
		long c = 300L;
		System.out.println(c);

		// 题目：
		// 可以吗？存在类型转换吗？
		// 2147483647默认被当做int来处理
		// d变量是long类型，小容量可以自动赋值给大容量，自动类型转换
		long d = 2147483647; // 2147483647是int最大值。
		System.out.println(d);

		// 编译器会报错吗？为什么？
		// 在java中，整数型字面量一上来编译器就会将它看做int类型
		// 而2147483648已经超出了int的范围，所以在没有赋值之前就出错了。
		// 记住，不是e放不下2147483648，e是long类型，完全可以容纳2147483648
		// 只不过2147483648本身已经超出了int范围。
		// 错误: 整数太大
		//long e = 2147483648;

		// 怎么解决这个问题呢？
		long e = 2147483648L;
		System.out.println(e);

	}
}

public class IntTest03{
	public static void main(String[] args){
		
		// 不存在类型转换
		// 100L是long类型字面量，x是long类型字面量。
		long x = 100L;

		// x是long类型，占用8个字节，而y变量是int类型，占用4个字节
		// 在java语言中，大容量可以“直接”赋值给小容量吗？不允许，没有这种语法。
		// 编译错误信息：错误: 不兼容的类型: 从long转换到int可能会有损失
		// int y = x;

		// 大容量转换成小容量，要想编译通过，必须加强制类型转换符，进行强制类型转换。
		// 底层是怎么进行强制类型转换的呢？
		// long类型100L：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
		// 以上的long类型100L强转为int类型，会自动将“前面”的4个字节砍掉：00000000 00000000 00000000 01100100
		int y = (int)x; // 这个(int)就是强制类型转换符，加上去就能编译通过。
						// 但是要记住：编译虽然过了，但是运行时可能损失精度。
		System.out.println(y); // 100

		// 定义变量a int类型，赋值100
		int a = 100;
		System.out.println(a);

		int b = a; // 将变量a中保存的值100复制一份给b变量。
		System.out.println(b);

	}
}

public class IntTest04{
	public static void main(String[] args){
		// 分析：以下代码编译可以通过吗？
		// 300 被默认当做int类型
		// b变量是byte类型
		// 大容量转换成小容量，要想编译通过，必须使用强制类型转换符
		// 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//byte b = 300;

		// 要想让以上的程序编译通过，必须加强制类型转换符
		// 虽然编译通过了，但是可能精度损失。
		// 300这个int类型对应的二进制：00000000 00000000 00000001 00101100
		// byte占用1个字节，砍掉前3个字节，结果是：00101100 (44)
		byte b = (byte)300;
		System.out.println(b); // 44

		// 这个编译能通过吗？
		// 1是int类型，默认被当做int类型来看。
		// x是byte类型，1个字节，大容量无法直接转换成小容量。
		// 按说是编译报错的。
		byte x = 1;
		byte y = 127;
		// 错误: 不兼容的类型: 从int转换到byte可能会有损失
		byte z = 128;

		// 当整数型字面量没有超出short类型取值范围的时候，该字面量可以直接赋值给short
		// 类型的变量。
		short s = 1;
		short s1 = 32767;
		// 错误: 不兼容的类型: 从int转换到short可能会有损失
		//short s2 = 32768;
		System.out.println(s);

	}
}

/*
	结论：byte、char、short做混合运算的时候，各自先转换成int再做运算。
*/
public class IntTest06{
	public static void main(String[] args){

		char c1 = 'a';
		byte b = 1;

		// 注意：这里的"+"是负责求和的
		System.out.println(c1 + b); // 98

		// 错误: 不兼容的类型: 从int转换到short可能会有损失
		//short s = c1 + b; // 编译器不知道这个加法最后的结果是多少。只知道是int类型。

		// 这样修改行吗？
		//错误: 不兼容的类型: 从int转换到short可能会有损失
		//short s = (short)c1 + b;

		short s = (short)(c1 + b);

		//short k = 98;

		int a = 1;
		//错误: 不兼容的类型: 从int转换到short可能会有损失
		// short x = 1; 可以
		short x = a; // 不可以，编译器只知道a是int类型，不知道a中存储的是哪个值。
		System.out.println(x);
	}
}

/*
	结论：多种数据类型做混合运算的时候，最终的结果类型是“最大容量”对应的类型。

	char+short+byte 这个除外。
	因为char + short + byte混合运算的时候，会各自先转换成int再做运算。
*/
public class IntTest07{
	public static void main(String[] args){
		
		long a = 10L;
		char c = 'a';
		short s = 100;
		int i = 30;

		// 求和
		System.out.println(a + c + s + i); //237

		// 错误: 不兼容的类型: 从long转换到int可能会有损失
		// 计算结果是long类型
		//int x = a + c + s + i;

		int x = (int)(a + c + s + i);
		System.out.println(x);

		// 以下程序执行结果是？
		// java中规定，int类型和int类型最终的结果还是int类型。
		int temp = 10 / 3; // / 是除号。（最终取整）
		System.out.println(temp); // 3.33333吗？结果是：3

		// 在java中计算结果不一定是精确的。
		int temp2 = 1 / 2;
		System.out.println(temp2); // 0

	}
}

public class FloatTest01{
	public static void main(String[] args){

		// 这个不存在类型转换
		// 3.1415926是double类型
		// pi是double类型
		double pi = 3.1415926;
		System.out.println(pi);

		// 这个可以吗？
		//错误: 不兼容的类型: 从double转换到float可能会有损失
		//float f = 3.14;

		// 怎么修改以上的代码呢？
		// 第一种方式:在字面量后面添加F/f
		//float f = 3.14f;
		//float f = 3.14F;

		// 第二种方式：强制类型转换，但可能损失精度。谨慎使用。
		float f = (float)3.14;
		System.out.println(f);

		// 分析这个程序，可以编译通过吗？
		// 错误: 不兼容的类型: 从double转换到int可能会有损失
		// 原理：先将5转换成double类型，然后再做运算，结果是double
		// 大容量无法直接赋值给小容量，需要强转。
		//int i = 10.0 / 5;

		// 怎么修改
		int i = (int)10.0 / 5;
		System.out.println(i); // 2

		// 可以这样修改吗？强转的时候只留下整数位。
		int x = (int)(10.0 / 5);
		System.out.println(x); // 2
	}
}

public class BooleanTest01{
	public static void main(String[] args){
		//错误: 不兼容的类型: int无法转换为boolean
		//boolean xingBie = 1;
	}
}

System.out.println(true & true); // true
System.out.println(true & false); // false
System.out.println(false & false); // false

System.out.println(true && true); // true
System.out.println(true && false); // false
System.out.println(false && false); // false

// 接下来需要理解一下什么是短路现象，什么时候会发生“短路”。
int x = 10;
int y = 11;
// 逻辑与&什么时候结果为true（两边都是true，结果才是true）
// 左边的 x>y 表达式结果已经是false了，其实整个表达式的结
// 果已经确定是false了，按道理来说右边的表达式不应该执行。
System.out.println(x > y & x > y++); 

// 通过这个测试得出：x > y++ 这个表达式执行了。
System.out.println(y); // 12

//测试短路与&&
int m = 10;
int n = 11;
// 使用短路与&&的时候，当左边的表达式为false的时候，右边的表达式不执行
// 这种现象被称为短路。
System.out.println(m > n && m > n++);
System.out.println(n); // 11

public class OperatorTest04{
	public static void main(String[] args){

		// 研究：
		// i += 10 和 i = i + 10 真的是完全一样吗？
		// 答案：不一样，只能说相似，其实本质上并不是完全相同。
		byte x = 100; // 100没有超出byte类型取值范围，可以直接赋值
		System.out.println(x); // 100

		// 分析：这个代码是否能够编译通过？
		// 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//x = x + 1; // 编译器检测到x + 1是int类型，int类型可以直接赋值给byte类型的变量x吗？

		// 使用扩展赋值运算符可以吗？
		// 可以的，所以得出结论：x += 1 和 x = x + 1不一样。
		// 其实 x += 1 等同于：x = (byte)(x + 1);
		x += 1;
		System.out.println(x); // 101

		// 早就超出byte的取值范围了。
		x += 199; // x = (byte)(x + 199);
		System.out.println(x); // 44 （当然会自动损失精度了。）

		int y = 100;
		y += 100;
		System.out.println(y); // 200

		y -= 100; // x = x - 100;
		System.out.println(y); // 100

		y *= 10; // x = x * 10;
		System.out.println(y); // 1000

		y /= 30; // x = x / 30;
		System.out.println(y); // 33

		y %= 10; // x = x % 10;
		System.out.println(y); // 3
		
	}
}

// 大家讨论最多的一个问题。
// 如果只是针对于面试题的话，建议死记硬背。
public class Homework01{
	public static void main(String[] args){
		int i = 10;
		i = i++;
		// 大部分同学都会认为这个i一定是11
		// 这个i变量最终的结果是10（惊讶）
		// 首先，第一点：这种代码以后不会有人写。
		// 其次：第二点：没必要讨论这个问题，因为在C++中运行结果确实是11.
		// java中运行结果是10
		// c++中运行结果是11
		// 为什么？因为java和c++的编译器是不同的人开发的。原理不同。
		System.out.println(i);
		
		// 在java语言中i++，这种表达式在执行的时候，会提前先将i变量找一个临时
		// 变量存储一下。(C++中并没有这样做。)
		/*
		int k = 10;
		k = k++;
		*/
		int k = 10;
		// k = k++;对应的是下面三行代码
		int temp = k;
		k++;
		k = temp;
		System.out.println(k);
	}
}

public class KeyInput{
	public static void main(String[] args){

		// 创建一个键盘扫描器对象
		// s 变量名，可以修改。其它不能改。 
		java.util.Scanner s = new java.util.Scanner(System.in); //这行代码写一次就行了。

		// 接收用户的输入，从键盘上接收一个int类型的数据
		// 解释这行代码，尽量让大家明白：代码执行到这里的时候，会暂停下来
		// 等待用户的输入，用户可以从键盘上输入一个整数，然后回车，回车之后
		// i变量就有值了。并且i变量中保存的这个值是用户输入的数字。
		// i变量就是接收键盘数据的。
		int i = s.nextInt(); // i是变量名，s是上面的变量名
		System.out.println("您输入的数字是：" + i);

		// 代码执行到此处又会停下来，等待用户的输入。
		// 敲完回车，s.nextInt();代码执行结束。
		int j = s.nextInt();
		System.out.println("您输入的数字是：" + j);

		// 如果输入的不是数字，那么会出异常：InputMismatchException
		int m = s.nextInt();
		System.out.println("您输入的数字是：" + m);

		// 我怎么从键盘上接收一个字符串呢？
		// 程序执行到此处会停下来，等待用户的输入，用户可以输入字符串。
		String str = s.next();
		System.out.println("您输入了：" + str);

		// 完整的。
		System.out.print("请输入用户名：");
		String name = s.next();
		System.out.println("欢迎"+name+"回来");
	}
}

/*
怎么用break;语句终止指定的循环呢？
	第一步：你需要给循环起一个名字，例如：
		a: for(){
			b:for(){
			}
		}
	第二步：终止：break a;
*/
public class BreakTest01{

	public static void main(String[] args){

		// 这种语法很少用，了解一下即可。
		a:for(int k = 0; k < 2; k++){ 
			b:for(int i = 0; i < 10; i++){
				if(i == 5){
					break a; // 终止指定的循环。
				}
				System.out.println("i ===> " + i); 
			}
		}

		System.out.println("呵呵");

	}
}// continue 也可以这样终止，但是开发中也很少用

[修饰符列表] 返回值类型 方法名(形式参数列表){
	方法体; 
}

// 在同一个域当中，"return语句"下面不能再编写其它代码。编写之后编译报错。
public static int m(){
	boolean flag = true;
	if(flag){
		return 1;
		//错误: 无法访问的语句
		//System.out.println("hello1");
	}
	// 这行代码和上面的代码hello1的区别是：不在同一个域当中。
	//System.out.println("hello2");
	return 0;
	// 错误: 无法访问的语句
	//System.out.println("hello3");
}

[修饰符列表] class 类名{
    // 类体 = 属性 + 方法
    // 属性在代码上以“变量”的形式体现
    //方法描述动作、行为
}

`public class XueSheng{ // 这个程序编译之后，会生成XueSheng.class字节码文件。
    // 属性
    // 学号（成员变量）
    int xueHao;
    // 姓名
    String xingMing;
    // 年龄
    int nianLing;
    // 性别
    boolean xingBie;
    // 住址
    String zhuZhi;
}

public class 明星类{
    double height;
}

public class Test{
    public static void main(String[] args){

        // 家庭住址对象
        Address a = new Address();
        a.city = "北京";
        a.street = "大兴区";
        a.zipcode = "121221";
        
        // 用户对象
        User u = new User();
        System.out.println(u.id); // 0
        System.out.println(u.username); // null
        System.out.println(u.addr); // null

        u.id = 11111;
        u.username = "zhangsan";
        u.addr = a;

    }
}

public class User{
    int id; // 实例变量
    String username; // 实例变量
    Address addr; 
}


// 住址类
public class Address{

    // 一个家庭住址有3个属性。
    // 城市
    String city; // 实例变量
    // 街道
    String street;
    // 邮编
    String zipcode;
}

public class NullPointerTest{
    public static void main(String[] args){
        // 创建客户对象
        Customer c = new Customer();
        // 访问这个客户的id
        System.out.println(c.id); // 0

        // 重新给id赋值
        c.id = 9521; // 终身代号
        System.out.println("客户的id是=" + c.id);
        //c = null;
        // NullPointerException
        // 编译器没问题，因为编译器只检查语法，编译器发现c是Customer类型，
        // Customer类型中有id属性，所以可以：c.id。语法过了。
        // 但是运行的时候需要对象的存在，但是对象没了，尴尬了，就只能出现一个异常。
        System.out.println(c.id);
    }
}

class Customer{
    // 客户id
    int id; // 成员变量中的实例变量，应该先创建对象，然后通过“引用.”的方式访问。
}

int x = 1;
int y = x; // 把x中保存1复制一份传给y
// x和y都是两个局部变量。

Person p1 = 0x1234;
Person p2 = p1; 把p1中保存的0x1234复制一份传给p2
// p1和p2都是两个局部变量。

public class Test2{
    public static void main(String[] args){
        Person p = new Person();
        p.age = 10;
        add(p);
        System.out.println("main--->" + p.age); //11
    }
    // 方法的参数可以是基本数据类型，也可以是引用数据类型，只要是合法的数据类型就行。
    public static void add(Person p){ // p是add方法的局部变量。
        p.age++;
        System.out.println("add--->" + p.age); //11
    }
}

class Person{
    // 年龄属性，成员变量中的实例变量。
    int age;
}

Student x = new Student();

Student y = new Student(123);

[修饰符列表] 构造方法名(形式参数列表){
    构造方法体;
    通常在构造方法体当中给属性赋值，完成属性的初始化。
}

[修饰符列表] 返回值类型 方法名(形式参数列表){
    方法体;
}

public class ConstructorTest01{
    public static void main(String[] args){

        // 调用Student类的无参数构造方法
        new Student();

        // 调用普通方法
        ConstructorTest01.doSome();
        doSome();

        // 创建Student类型的对象
        Student s1 = new Student();

        // 输出“引用”
        //只要输出结果不是null，说明这个对象一定是创建完成了。
        // 此处的输出结果大家目前是看不懂的，后期再说。
        System.out.println(s1); //Student@54bedef2

        // 这是调用另一个有参数的构造方法。
        Student s3 = new Student(100);
        System.out.println(s3); //Student@5caf905d
    }

    public static void doSome(){
        System.out.println("do some!!!!");
    }
}

public class Person{
    // private 表示私有的，被这个关键字修饰之后，该数据只能在本类中访问。
    // 出了这个类，age属性就无法访问了。私有的。
    private int age; // 每一个人年龄值不同，对象级别的属性。

    // 写一个方法专门来完成读。(get)
    // 写一个方法专门来完成写。(set)
    // get和set方法应该带有static，还是不应该有static,get和set方法应该定义为实例方法吗？
    // get读年龄，set改年龄，这个读和改都是操作的一个对象的年龄。（没有对象何来年龄）
    // 封装的第二步：对外提供公开的set方法和get方法作为操作入口。并且都不带static。都是实例方法。
    /*
        [修饰符列表] 返回值类型 方法名(形式参数列表){
        }

        注意：
            java开发规范中有要求，set方法和get方法要满足以下格式。
                get方法的要求：
                    public 返回值类型 get+属性名首字母大写(无参){
                        return xxx;
                    }
                set方法的要求：
                    public void set+属性名首字母大写(有1个参数){
                        xxx = 参数;
                    }
            
            大家尽量按照java规范中要求的格式提供set和get方法。
            如果不按照这个规范格式来，那么你的程序将不是一个通用的程序。

    */
    // get方法
    public int getAge(){
        return age;
    }

    // set方法
    public void setAge(int nianLing){
        // 能不能在这个位置上设置关卡！！！！
        if(nianLing < 0 || nianLing > 150){
            System.out.println("对不起，年龄值不合法，请重新赋值！");
            return; //直接终止程序的执行。
        }
        //程序能够执行到这里，说明年龄一定是合法的。
        age = nianLing;
    }
}

//带有static的方法
//没有static的方法
//分别怎么调用？
    //带有static的方法怎么调用？通过“类名.”的方式访问。

//对象被称为实例。
//实例相关的有：实例变量、实例方法。
//实例变量是对象变量。实例方法是对象方法。
//实例相关的都需要先new对象，通过“引用.”的方式去访问。
public class MethodTest{

    /*
    public MethodTest(){
    
    }
    */

    public static void main(String[] args){
        MethodTest.doSome();
        //类名. 可以省略（在同一个类中。）
        doSome();
        // 尝试使用“类名.”的方式访问“实例方法”
        // 错误的
        //MethodTest.doOther();
        
        // 创建对象
        MethodTest mt = new MethodTest();
        // 通过"引用."的方式访问实例方法。
        mt.doOther();

    }	

    // 带有static
    public static void doSome(){
        System.out.println("do some!");
    }

    //这个方法没有static，这样的方法被称为：实例方法。（对象方法，对象级别的方法）
    //这个没法解释，大家目前死记硬背。
    public void doOther(){
        System.out.println("do other....");
    }

}

/*
空指针异常导致的最本质的原因是？
    空引用访问“实例相关的数据”，会出现空指针异常。
    实例相关的包括：实例变量 + 实例方法。
*/
public class NullPointerTest{
    public static void main(String[] args){
        User u = new User();
        System.out.println(u.id); // 0
        u.doSome();

        // 引用变成空null
        u = null;

        // id的访问，需要对象的存在。
        //System.out.println(u.id); // 空指针异常

        // 一个实例方法的调用也必须有对象的存在。
        //u.doSome(); // 空指针异常。
    }
}


// 类 = 属性 + 方法
// 属性描述状态
// 方法描述行为动作
class User{

    // 实例变量
    int id;

    // 实例方法（对象相关的方法，对象级别的方法，应该是一个对象级别的行为。）
    // 方法模拟的是对象的行为动作。
    public void doSome(){
        System.out.println("do some!");
    }

    // 考试的行为，由于每一个人考试之后的分数不一样，所以考试行为应该必须有对象的参与。
    public void exam(){
        
    }
}

/*
    static:
        1、static翻译为“静态”
        2、所有static关键字修饰的都是类相关的，类级别的。
        3、所有static修饰的，都是采用“类名.”的方式访问。
        4、static修饰的变量：静态变量
        5、static修饰的方法：静态方法

    变量的分类：
        变量根据声明的位置进行划分：
            在方法体当中声明的变量叫做：局部变量。
            在方法体外声明的变量叫做：成员变量。

        成员变量又可以分为：
            实例变量
            静态变量
*/

class VarTest{

    // 以下实例的，都是对象相关的，访问时采用“引用.”的方式访问。需要先new对象。
    // 实例相关的，必须先有对象，才能访问，可能会出现空指针异常。
    // 成员变量中的实例变量
    int i;

    // 实例方法
    public void m2(){
        // 局部变量
        int x = 200;
    }


    // 以下静态的，都是类相关的，访问时采用“类名.”的方式访问。不需要new对象。
    // 不需要对象的参与即可访问。没有空指针异常的发生。
    // 成员变量中的静态变量
    static int k;

    // 静态方法
    public static void m1(){
        // 局部变量
        int m = 100;
    }
    
}

/*
    什么时候变量声明为实例的，什么时候声明为静态的？
        如果这个类型的所有对象的某个属性值都是一样的，不建议定义为实例变量，浪费内存空间。建议定义为类级别特征，定义为静态变量，在方法区中只保留一份，节省内存开销。

    一个对象一份的是实例变量。
    所有对象一份的是静态变量。
*/

// 定义一个类：中国人
class Chinese{

    // 身份证号
    // 每一个人的身份证号不同，所以身份证号应该是实例变量，一个对象一份。
    String idCard; 

    // 姓名
    // 姓名也是一个人一个姓名，姓名也应该是实例变量。
    String name;

    // 国籍
    // 重点重点五颗星：加static的变量叫做静态变量
    // 静态变量在类加载时初始化，不需要new对象，静态变量的空间就开出来了。
    // 静态变量存储在方法区。
    static String country = "中国";

    // 无参数
    public Chinese(){
    
    }

    // 有参数
    public Chinese(String s1,String s2){
        idCard = s1;
        name = s2;
    }
}



/*
    实例的：一定需要使用“引用.”来访问。

    静态的：
        建议使用“类名.”来访问，但使用“引用.”也行（不建议使用"引用."）。
        静态的如果使用“引用.”来访问会让程序员产生困惑：程序员以为是实例的呢。
    
    结论：
        空指针异常只有在什么情况下才会发生呢?只有在“空引用”访问“实例”相关的，都会出现空指针异常。
*/

/*
    关于方法来说，什么时候定义为实例方法？什么时候定义为静态方法？
        有没有参考标准。

        此方法一般都是描述了一个行为，如果说该行为必须由对象去触发。
        那么该方法定义为实例方法。

        参考标准：
            当这个方法体当中，直接访问了实例变量，这个方法一定是实例方法。

            我们以后开发中，大部分情况下，如果是工具类的话，工具类当中的方法
            一般都是静态的。(静态方法有一个优点，是不需要new对象，直接采用类名
            调用，极其方便。工具类就是为了方便，所以工具类中的方法一般都是static的。)

            什么是工具类？？？？？
                以后讲。（工具类就是为了方便编程而开发的一些类。）
    
    类 = 属性 + 方法
        属性描述的是：状态
        方法描述的是：行为动作
    
    一个方法代表了一个动作。

*/