被java语言赋予了特殊含义的单词

组成关键字的字符全部小写
类似notepad++的高级记事本软件，针对关键字都有特殊颜色的标记

就是给类，接口，方法，变量,包等起名字的时候使用的字符序列

• 英文大小写字母
• 数字字符
• $ 和 _

1. 不能以数字开头

2. 不能是java中关键字

3. 区分大小写

4. 要做到见名知意
   举例

 //定义一个学生类
      class Student{
   
   }

• 其实就是文件夹，作用是用来把想同的类名进行区分，进行分类存储
• 给包命名的时候全部小写
• 分类：
  单级包 momo
  多级包 com.momo
  　com
  　　-momo

• 一个单词：单词的首字母必须大写
  Student Dog Cat …
• 多个单词：每个单词的首字母都大写
  HelloWorld MeiNv …

• 一个单词：单词小写
  int age 　String name 　max() 　min()
• 多个单词：从第二个单词开始，每个单词的首字母大写
  int studentAge
  String studentName
  showAll()

一个单词：全部大写
PI AGE NAME

多个单词：每个单词的每个字母都大写，每个单词之间用_隔开
MAX_AGE 　 MIN_AGE 　STUDENT_MAX_AGE

class Demo{
	public static void main(String[] args){
		//正确的
		int age = 18;
		//int 2age = 20;//错误的
		int _age2 = 20;
	    // 非法的表达式开始
	    //int public = 55;
	
	    int Public = 66;
	
	    int MAX_AGE = 777;
	    System.out.println(age);
	    }
}

用于程序解释说明的文字

• 单行注释
  格式：//注释内容
• 多行注释
  格式：/* 注释内容 */
  注意：不能嵌套使用
• 文档注释
  格式：/** 注释内容 */

• 解释说明程序
• 提高程序的阅读性
• 可以帮助我们简单的调式程序（后面有高级调式）

//这是注释案例演示
class Demo2{
	//这里是主方法
	//是程序的入口
	//被jvm调用
	public static void main(String[] args){
		//我要输出我是大帅哥
		//需要一个输出语句
		System.out.println("我是一个大帅哥");
		System.out.println("我是一个大帅哥");
		System.out.println("我是一个大帅哥");
		//System.out.println("我是一个大帅哥");
		//System.out.println"我是一个大帅哥");
	}
}

文档注释是java特有的，可以被javadoc命令解释，生成一套网页形式的说明文档（后面讲）。

• 注释是一个有序程序员必须有的良好的习惯
• 大家以后写代码的时候先写注释再写代码
• 把自己的思路用注释先整理出来，然后再用代码去体现，代码仅仅是思想的一种具体体现而已。

在程序执行过程中其值不可以发生改变

• ​ 字符串常量：用""括起来的
  ​ “helloworld” “123” “abc”…
• ​ 整数常量:所有的整数
  ​ 1，111，11111，65464
• ​ 小数常量：所有的小数
  ​ 1.11 3.14 5.2666
• ​ 字符常量：用 单引号 括起来的 单个内容
  ​ ‘a’ ‘0’
  'abc’这个是错的
• ​ 布尔常量：比较特殊 只有true和false
• ​ 空常量： null

class Demo3{
	public static void main(String[] args){
		//字符串常量的输出
		System.out.println("我是一个大帅哥");
		//整数常量的输出
		System.out.println(123);
		//小数常量的输出
		System.out.println(1.23);
		//字符常量的输出
		System.out.println('a');
		System.out.println('A');
		System.out.println('0');
		//布尔常量的输出
		System.out.println(true);
		System.out.println(false);
	}
}

• 二进制
• 八进制
• 十进制
• 十六进制

• 概述：进制就是进位制，是一种进位方法

• 对于任何一种进制，x进制，就表示某一位置上的数运算的时候就是逢x进一位，

  二进制逢二进一 八进制逢八进一 十进制逢十进一 十六进制逢十六进一。

• 任何数据在计算机中都是以二进制的形式存在的
• 二进制早期是由电信号开关演变而来的
• 一个整数在内容中也是二进制，但是使用一串1或者0组成的数值进行使用的话很麻烦
  

• 二进制：由1和0组成 以0b开头
• 八进制：由0，1，2…7 以0开头
• 十进制：0，1，2，3.。。。9 整数默认是十进制
• 十六进制：由0,1,2…9,abcdef组成，以0x开头

//不同进制的数据组成
class Demo4{
	public static void main(String[] args){
		System.out.println(100);//默认十进制
		System.out.println(0b100);//二进制
		System.out.println(0100);//八进制
		System.out.println(0x100);//十六进制
	}
}

• 其他进制到十进制： 系数*基数的权次幂相加
  

  -练习：计算下面数据的十进制
  0b101：8²+8⁰=65

• 十进制到其他进制
  

  -练习：获取下面数据的二进制，八进制，十六进制
  55
  88

• 十进制和二进制的快速转换
  8421码可以实现十进制和二进制之间的快速转换，是大陆的叫法，是BCD码中最常用的一种。
  在8421码中每一位上的1都有一个固定的数值。
  把每一位上的1所表示的十进制数值加起来，就能够得到最终的十进制结果
  1　　1　　1　　1　1　1　　1　1
  128　64　3２　16　8　４　２　1

• 二进制和八进制，十六进制可以使用十进制作为桥梁 先拆分，在组合
  -任意的x进制到y进制的转换，怎么转？
  x进制----------十进制
  十进制---------y进制

在计算中，有符号的数据有3中表示方法：原码，反码，补码
所有的数据在运算的时候都是采用补码进行运算的

• 原码：就是数据的二进制表示，最高位是符号位，0表示正 1表示负，其余都是数值位

• 反码：正数的反码和原码一样，负数的反码是对原码逐个取反（0变1，1变0）但是符号位除外

• 补码：正数的补码和原码一样，负数的补码是在反码的基础上加1
  

  练习：假设某数据x的原码是 1011 0100 求x的补码和反码

​ 反码： 1100 1011

​ 补码： 1100 1100

​ 练习：假设某数据x的补码是 1011 0100 求x的原码

​ 反码： 1011 0011

​ 原码： 1100 1100

在程序执行过程中其值可以在某个范围发生改变的量

• 必须对其进行限定，使用数据类型
• 我们在运算的时候，不可能拿些这个空间去运算，真正要用的是这个空间中的值，我们就给空间起一个名字----- 变量名
• 类型有了，名字有了，但是如果这个空间里面没有值，就没有意义，它就是一个垃圾空间，需要给它一个初始化值

• 数据类型 变量名 = 初始化值 格式是固定的
• 从本质上讲，变量其实是内存中的一个小区域，使用变量名来访问这个区域。所以每一个变量使用先必须先申请(声明)然后赋值，才能使用。
• 为什么要定义变量？
  用来不断存放同一类型的常量，并且可以重复使用。

对于每一种数据都定义了明确的具体的数据类型
在内存中分配了不同大小的空间

基本数据类型 4类8种

整数类型　占用的字节　　取值范围
​byte　　　　1　　　　　-128到127
​short　　　　2　　　　　-2¹⁵到2¹⁵-1
​int　　　　　4　　　　　-2³¹到2³¹
​long　　　　8 　　　　　-2⁶³到2⁶³ -1
​浮点类型
​float　　　　4
double　　　8

​ char 2

​ boolean 1

• 整数默认是int类型 浮点型默认是double类型
• 长整型后面要使用L或者l标记 建议用L
• 单精度浮点数据要用F或者f来标记 建议用F
  ​

class Demo5{
	public static void main(String[] args){
		//定义一个变量   数据类型 变量名  = 初始值
		//定义一个字节类型
		byte b = 11;
		System.out.println(b);
		System.out.println(11);
		b = 22;
		System.out.println(b);
        //定义一个短整型类型
        short s = 111;
        System.out.println(s);

        //定义一个整型类型
        int i = 1111;
        System.out.println(i);
        //错误: 过大的整数
        //i = 1111111122222;
        System.out.println(i);

        //定义一个长整型类型
        //long l = 11111;
        //long l = 1111111122222;// 过大的整数
        long l = 1111111122222L;
        System.out.println(l);

        //定义浮点数据
        // 错误: 不兼容的类型: 从double转换到float可能会有损失
        float f = 12.13F;
        System.out.println(f);

        double d = 12.13;
        System.out.println(d);

        //字符型变量
        char ch = 'a';
        System.out.println(ch);

        //布尔类型
        boolean boo = true;
        System.out.println(boo);
    }
}

​ 类 　　　class
​ 接口 　 interface
​ 数组 　 []

• 作用域
  变量定义在哪一级的大括号中，这个括号的范围就是这个变量的作用域
• 相同的范围内不能出现同名的变量
• 初始值
  没有初始值的变量不能使用
  只要在使用之前给值就行，不一定要在定义的时候就给它
• 建议一行上面之定义一个变量
  可以定义多个，但是不建议

class Demo6{
	public static void main(String[] args){
		//定义一个变量
		int x = 100;
		x = 111;
		//int x = 111;错误: 已在方法 main(String[])中定义了变量 x
		System.out.println(x);
		{
			System.out.println(x);
        int i;
            //使用之前那给值就行
            i = 55;
            // 错误: 可能尚未初始化变量i
            System.out.println(i);
        }
        //错误: 找不到符号
        //System.out.println(i);
        //一行上可以定义多个，但是不建议
        //int a = 5;int b = 6;int c = 7;
        int a = 5;
        int b = 6;
        int c = 7;

        //int ii;int jj;
        //int ii,int jj;错误的
    }
}

/*
+是一个运算符，可以做加法运算

一般来说我们在运算的时候，要求参与运算的数据类型必须一致。
不一致也可以，但是会有类型的转换过程
注意：boolean类型不能转换成其他类型

默认转换（从小到大的转换）
	byte,short,char------int----long----float---double
	byte,short,char他们之间不转换，他们参与运算的时候都会先转成int类型
*/
class Demo7{
	public static void main(String[] args){
		//直接输出2个常量做加法运算
		System.out.println(5+6);
		
        //2个int类型
        int x = 5;
        int y = 6;
        int z = x+y;
        System.out.println(x+y);
        System.out.println(z);

        //一个byte，一个int
        byte b = 6;
        int i = 6;
        System.out.println(b+i);//12
        // 错误: 不兼容的类型: 从int转换到byte可能会有损失
        //byte c = b+i;
        int c = b+i;
        System.out.println(c);

        byte bb = 5;
        short ss = 3;
        // 不兼容的类型: 从int转换到short可能会有损失
        //short sss = bb+ss;
        int sss = bb+ss;
        System.out.println(sss);
        System.out.println(bb+ss);
    }
}

• boolean类型不能转换成其他类型

• 默认转换（从小到大的转换）
  byte,short,char------int----long----float—double
  byte,short,char他们之间不转换，他们参与运算的时候都会先转成int类型

• 强制转换（从大到小的转换）
  目标类型 变量名 = (目标类型)(要被转换的数据)

• 注意：不要随便使用强制转换，因为它有可能会损失精度

class Demo8{
	public static void main(String[] args){
		byte a = 3;
		int b = 4;
		
        //int c = a+b;//肯定没有问题
        //System.out.println(c);

        byte aa = 7;
        //byte cc = a+b;//这个有问题
        //可以使用强制类型转换
        byte cc = (byte)(a+b);
        System.out.println(cc);
    }
}

• 大家看下面这个有没有问题
  double d = 12.345;
  float f = d;

• 大家看下面的有没有区别
  float f1 = (float)12.345;
  float f2 = 12.345F;

class Demo9{
	public static void main(String[] args){
		//double d = 12.345;
		//float f = (float)d;
        float f1 = (float)12.345;
        float f2 = 12.345F;
        //f1是通过double类型强转而来
        //f2本身就是一个float类型
    }
}

/*
  byte b1 = 3,b2 = 4,b;
  b = b1+b2;
  b = 3+4;
  问，那句会编译失败？为什么？
   b = b1+b2;这个有问题，
   这个是变量相加，先看类型，最后结果赋值的时候也要考虑类型
   常量相加，先做加法运算，然后看结果是否在赋值的类型范围内，在就不错，不在才报错。
*/
class Demo9{
	public static void main(String[] args){
		//定义了3个byte类型的变量  b1,b2,b1  b1的值是3，b2的值是4，b没有值
		byte b1 = 3,b2 = 4,b;
		//b = b1+b2;错误: 不兼容的类型: 从int转换到byte可能会有损失
		//b = 3+4;//先加计算结果  7  看在不在byte范围内  在  不报错
		//byte bb = 3+4;//7   byte bb = 7;
	System.out.println(b);
	}
}

/*
问：byte b = 130;有没有问题？如果有怎么可以让它不报错？结果是多少？为什么？
分析：
	要知道结果为什么是-126 ，我们需要知道它是如何计算的
	前面我们说过数据都是采用补码进行运算的，要获取补码先要获取原码
	原码简单说就是数据的二进制表示
	130的二进制：00000000 00000000 00000000 10000010
	因为是正数，所以这即使原码也是反码也是补码
	

然后我们进行了强制转换（byte占用一个字节）所以进行截取、
		符号位    数值位
 补码   1         0000010    符号位是1表示是负数
 反码   1         0000001
 原码	  1         1111110           -  64+32+16+8+4+2=  -126
*/
class Demo10{
	public static void main(String[] args){
		//byte 的范围是-128到127  130超范围了，所以报错
		//byte b = 130;// 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//使用强制类型转换
		byte b = (byte)130;
		System.out.println(b);//-126
	}
}

• 练习：byte b = 330;

• 字符参与运算（ASCII表）

/*
 通过这个简单的演示，字符可以和整数相加，结果是一个整数
 为社么呢？因为每个字符其实都有一个对应的数值
 这个值在  ASCII表中
	简单看过这个表之后我们需要记住3个即可
	'a'   97
	'A'   65
	'0'   48


*/
class Demo12{
	public static void main(String[] args){
		//输出一个字符
		System.out.println('a');//a
		//输出一个字符和一个整数相加
		System.out.println('a'+1);//98
	}
}

• ***字符串参与运算

/*
字符串数据和其他数据做+，结果是一个字符串
这里的+就不在是+运算，而是字符串连接符
*/
class Demo11{
	public static void main(String[] args){
		//输出一个字符串
		/*
		System.out.println("aaa");
		System.out.println("aaa"+111);
		System.out.println(111+"aaa");
		System.out.println(11+"aaa"+11);
		System.out.println(11+22+"aaa"+111);//33aaa111
		System.out.println("aaa"+true);
		*/
		System.out.println("hello"+'a'+1);//helloa1
		System.out.println('a'+1+"hello");//98hello
	
        System.out.println("6+6="+6+6);//6+6=66
        System.out.println(6+6+"=6+6");//12=6+6
        int a = 5;
        int b = 6;
        System.out.println("a="+a);
        System.out.println("b="+b);
        System.out.println("a="+a+",b="+b);

        }
}