Java学习笔记

目录

基础

注释

标识符

变量

数据类型

---

基础

注释

目的：让程序员能够更快速的理解代码。

三种方式：

第一种单行注释：

//  单行注释

第二种多行注释：

/*

*这里的注释为多行注释：

*第一行注释，，，

*/

第三种javadoc注释：

/**

*这里注释为Javadoc注释

*@author作者姓名

*@version 版本号

*@since自从哪个版本号就开始了

*/

标识符

标识符（identifier）是指用来标识某一个实体的一个符号，是用户编程时使用的名字，用于给变量，常量，函数，语句块等命名。

在编程语言中，标识符就是程序员自己规定的代表一定含义的单词（Java源程序当中凡是由程序员自己有权利修改的名字），比如类名，属性名，变量名等。

如下：

public class Student{
int age;
public void setAge(int a){
     age=a;
   }
}

其中，Student是一个类名，表示学生类；age是一个属性名表示学生的年龄属性，setAge是一个方法名，a表示一个变量名。这些都是标识符。

在Java源程序当中，标识符可以用来标识：

  * 类名。例如：Student 学生类，User 用户类，Product 商品类等。

  *接口名。例如：Runable 可运行的，Comparable 可比较的等。

  *变量名。例如：name 名字，age 年龄，birth 生日，length 长度等。

  *方法名。例如：login 登录，logout 登出，eat 吃，drink 喝等。

  *常量名，例如：LOGIN_SUCCESS  ACCESS_TOKEN等。

标识符命名规则（掌握）

1. 标识符只能由数字，字母，下划线"_"，美元符"$"组成，不能包含其他符号。
2. 标识符不能以数字开始。
3. Java关键字和保留字不能作为标识符。
4. 标识符严格区分大小写。
5. 标识符理论上没有长度限制。

标识符命名规范（掌握）

1. 见命知意：看到这个单词就知道它表示什么，增强程序的可读性，例如：Student 则表示学生类型，User 则表示用户类型；
2. 遵循驼峰命名法：可以更好的分隔单词，每个单词之间会划清界限，增强程序的可读性，例如：getName 则表示获得名字，UserService则表示用户业务类；
3. 类名，接口名首字母大写，后面每个单词首字母大写。
4. 变量名，方法名首字母小写，后面每个单词首字母大写。
5. 常量名全部大写，单词与单词之间使用"_"衔接，为了表示清楚含义，不怕单词长，例如：INT_MAX_VALUE 则表示int类型最大值。

关键字（理解）

Java关键字是编程语言里事先定义的，有特殊意义的单词，所有关键字都是小写的英语单词（在Java里），他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作标识符。

常见的关键字，如下表所示：

byte	short	int	long	float
double	boolean	char	if	for
else	while	do	continue	break
public	default	protected	private	throw
throws	try	catch	final	finally
case	switch	transient	package	new
static	this	abstract	strictfp	native
goto	super	extends	impements	import
instanceof	return	synchronized	void	const
class	cnum	assert	interface	volatile

这些关键字目前不需要背，后面代码写的多了，自然就记住了。

变量

变量是内存当中存储数据最基本的单位，将数据（字面量）放到内存当中，给这块内存空间起一个名字，这就是变量。

所以变量就是内存当中的一块空间，这块空间有名字，有类型，有值，这也是变量必须具备的三要素。

变量在内存中的抽象图形可以参考下图：

 使用变量（掌握）

   数据类型   变量名;

public class VarTest01{
    public static void main(Strint[] agrs){
        int age;
   }
}

上面代码中age变量的三要素只具备了俩个要素：数据类型和变量名，此时  age  变量没有存储数据（或者说没有赋值），那么这个age是不可以访问的。

public class VarTest01{
   public static void main(String[] agrs){
      int age;
      System.out.println(age);
}
}

此时运行程序会报错：可能尚未初始化 age。

在Java语言中给变量赋值需要采用赋值符号 " = " 语法格式如下： 

   变量名 = 值；

public class VarTest01{
  public static void main(String[] agrs){
      int age;
      age=20;    //或者可以之间赋值 int age=20;
      System.out.println(age);
}
}

此时程序就会运行出结果  20。

变量赋值后可以再次赋值，所以才可称为变量。

public class VarTest01{
public static void main(String[] agrs){
        int age;
        age=20;    
        System.out.println(age);
        age=30;
        System.out.println(age);
    }
}

第一次输出20，

第二次输出30。

Java允许一次声明多个同类型的变量。

public class VarTest01{
   public static void main(String[] agrs){
        int age=20,a=30,c=40;
       System.out.println(age);
       System.out.println(a);
       System.out.println(c);
    }
}

注：但是不允许同时给三个变量赋同一个值：

       int  a,b,c=400;

       此时程序会报错。

如下代码：

public class VarTest01{
   public static void main(String[] agrs){
        int age=20;
        int age=30;
       System.out.println(age);
    }
}

第四行会报错，在同一个大括号（同一块域）里面不能同时声明多个同名的变量。在执行时，Java虚拟机不知道该访问哪个变量。

变量分类：

根据位置不同可分为：局部变量和成员变量。

局部变量：在方法体中声明的变量以及方法的每一个参数都是局部变量。

成员变量：在方法体外，类体内声明的变量称为成员变量。

注：成员变量在声明时如果使用了  static  关键字修饰的为静态成员变量（简称静态变量），如果没有  static  关键字修饰则称为实例成员变量（简称实例变量）。

public class VarTest06{
   int x=20;  //实例变量
   static int y=200;  //静态变量
   public static void sum(int a,int b){  //局部变量a和b
   int firstNum=100;  //局部变量
  }
}

数据类型

Java数据类型包括俩大类：基本数据类型和引用数据类型。

基本数据类型包括4类8种：

第一类：整数型（不带小数的数字）：byte，short，int，long

第二类：浮点型（带小数的数字）：float，double（默认）

第三类：字符型（文字，单个字符）：char

第四类：布尔型（真和假）：boolean

Java中的字符串属于引用数据类型。

八种基本类型：byte，short，int，long，float，double，boolean，char

数据类型	占字节数	取值范围	缺省默认符
byte(字节型)	1	[-128-127]	0
short(短整型)	2	[-32768~32767]	0
int(整型)	4	[-2147843648~2147483647]	0
long(长整型)	8	[-2^63~2^63-1]	0L
float(单精度)	4	[-2^31~2^31-1]	0.0f
double(双精度)	8	[-2^63~2^63-1]	0.0
boolean(布尔型)	1	true,false	false
char(字符型)	2	[0~2^16-1],[0~65535]	'\u0000'

通过上表已经知道每个数据类型所占的字节，那么字节是什么呢？大家都知道一个字节是8比特位，一个比特位就是一个1或者0，也就是说一个字节由8个1和0组成的二进制数字串。

1byte=8bit（一个字节是八个比特位）

1KB=1024byte

1MB=1024KB

1GB=1024MB

1TB=1024GB

数据类型详解：

1.字符型

字符型char在Java语言中占俩个字节，char类型的字面量必须使用单引号括起来，取值范围为[0~65535]，char和short都占用俩个字节，但是char可以取到更大的正整数，因为char类型没有负数。可以容纳一个汉字。

public class CharTest01{
   public static void main(String[] agrs){
   char a='笨';
   System.out.println(a);  
  }
}

在Java中char型采用 unicode 编码，这样无论文字还是英文字符都占用俩个字符的内存空间。

public class CharTest01{
   public static void main(String[] agrs){
    char c1=97;
   System.out.println(c1);  
    char c2='a'+1;
   System.out.println(c2);  
    char c3='0'+'1'; 
   System.out.println(c3);  
  }
}
//输出结果为  a b a

 

2.整型

整数型数据在Java中有四种表达方式，分别为十进制，八进制，十六进制，二进制。

• 以0x开始表示十六进制
• 以0b开始表示二进制
• 以O开始表示八进制
• 默认为十进制

• 十进制：0，1，2，3，4，5，6，7，8，9，10，12，13，14，15，16……
• 八进制：0，1，2，3，4，5，6，7，10，11，12，13，14，15，16，17，20，21……
• 十六进制：0，1，2，3，4，5，6，7，8，9，，a,b,c,d,e,f,10,11……

 代码中试验一下以上几种写法

public class Text {
        public static void main(String[] agrs){
            System.out.println("十进制:"+10);
            System.out.println("八进制:"+010);
            System.out.println("十六进制:"+0x10);
            System.out.println("二进制:"+0b10);
                }
        }
//输出结果为
//十进制:10
//八进制:8
//十六进制:16
//二进制:2

在实际开发中，大部分还是直接使用十进制的方式，程序的可读性更好一些。

在Java语言中，整数型字面量被当作int类型处理，也就是说在程序中只要遇到整数型的数字，该数字会默认被当作int类型处理，如果想表示long类型则需要在字面量的后面添加L/l，建议大写L，好区分。

public class IntegerTypeTest02{
 public static void main(String[] args){
  int a=10;
  long b=10L;
  long c=10;
  System.out.println(c);
  }
}

在第五行新增了一句代码 long c=10; 这种编译方法符合语法规则，java中会将10默认当作int类型处理，而 c 变量是 long 类型，int 类型可以转化为 long 类型，因为 int 占4个字节，而 long 占8个字节，在Java中小容量可以之间赋值给大容量。被称为自动转换。

public class IntegerTypeTest02{
 public static void main(String[] args){
  int a=10;
  long b=10L;
  long c=10;
  System.out.println(c);
  int d=c;    //报错
  }
}

在第7行会报错 int d=c; 报错显示：不兼容的类型，从long转换到int 可能会有损失。这是因为c 变量是long类型占用八个字节，而负责接受的d变量是int 类型占用4个字节，很明显是大容量转换成小容量，好比大水杯中的水倒向小玻璃杯，最终结果可能会使水溢出。

这时编译器不会自作主张，需要程序员自己来指定，因为数据的损失需要程序员知晓，毕竟数据损失是一件严重的事，编译器不会自己负责。则编译器必须手动添加强制转换符才可以编译通过。这个过程称为强制转换。

public class IntegerTypeTest02{
 public static void main(String[] args){
  int a=10;
  long b=10L;
  long c=10;
  System.out.println(c);
  int d=(int)c;
  }
}

我们可以看到第七行的代码修改为 int d=(int)c；这就是强制转换，语法格式就是在需要强制转换的数据前添加小括号，小括号中写上要转换的类型。

通过以上我们得到一条结论：

一个数据在赋值给变量时有三种情况：

• 第一种情况是类型一致，不需要类型转换
• 第二种情况是小容量可以自动赋值给大容量（自动转换）
• 第三种情况是大容量不能直接赋值给小容量，如果一定要赋值给小容量，必须加强制类型转换符进行强制转换操作（精度损失）

public class Test {
    public static void main(String[] args){
        int a=300;
        byte b=(byte) a;
        System.out.println("b="+b);
    }
}

以上代码运行结果为44。

这是因为 int 类型的 300 对应的二进制为：00000000  00000000  00000001  00101100，强制转换的时候会变成一个字节，这时候底层会把前三个字节全部砍掉，最后只剩下00101100，对应的十进制自热就是44了。（精度损失）

再看看精度损失为负数的情况。

public class Test {
    public static void main(String[] args){
        int a=150;
        byte b=(byte) a;
        System.out.println("b="+b);
    }
}

他的运行结果为-106，这是因为计算机在任何情况下都是采用二进制补码的形式存储数据的（了解就好）。计算机二进制包括原码，反码，补码。对于正数来说原码，补码，反码是同一个。对于负数，负数的反码是在其原码的基础上，符号位不变，其余各位相反，例如：-15的原码是10001111，-15反码是11110000。负数的补码是在其反码上加1。-15的补码就是1111001二进制来表示。

再看以上程序，int a =150; 4个字节的150的二进制为00000000 00000000 00000000 10010110，强制转换时前三位砍掉，最后计算机存储的二进制为10010110。这个时计算机存储的补码的形式，然后推出原码：负数的补码是反码加1，所以100100110-1就是反码10010101，反码的符号位不变，其余取反11101010（第一位是符号位），得到原码11101010，而这个值就是-106。实际中用到的不多，原理知道即可。