JAVA语言基础

最新推荐文章于 2023-11-21 22:22:17 发布

wenqiang su

最新推荐文章于 2023-11-21 22:22:17 发布

阅读量190

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_42681868/article/details/84981026

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

输出Hellow World：

新建一个文本，后缀为java，文件名为类名

class HelloWorld{
	 public static void main(String[] args){
		System.out.println("Hello World,this is my first java code");
	}
}

进入终端的该文件所在位置，编译文件：javac HelloWorld.java ，运行文件：java HelloWorld

注释：

单行注释： //注释内容
多行注释：/* 注释内容*/
文档注释： /** 注释内容 **/

class HelloWorld {                                                     //这是一个类名的声明，类名是Hello world
	 public static void main(String[] args) {                          //这是一个主方法，是程序的入口
		System.out.println("Hello World,this is my first java code");  //这是输出语句，会在控制台输出一句话
	}
/*
这里是多行注释
这里是多行注释2
这里是对行注释哦
*/
}

关键字：

标识符：

标识符概述：就是给类，接口，方法，变量等起名字时使用的字符序列
组成规则：
1.英文大小写字母
2.数字字符
3.$ , _
注意事项：
1.不能数字开头
2.不能时java总的关键字
3.区分大小写

命名规则：

包：其实就是一个文件夹，用于解决相同类名问题
例：包名命名一般时全部小写，一般时域名倒写。如www.123.com , com.123.包的作用

类或者接口：如果时一个单词，要求首字母大写，如果时多个字母，每个字母的首字母大写

方法和变量：如果时一个单词，每个字母都小写，如果是多个字母，第二个单词开始首字母大写
例：getName , setName

常量：如果是一个单词，所有字母大写，如果是多个单词，全部大写，并以下划线分开单词
例：MAX_VALUE

常量：

class Demo_Constant 
{
	public static void main(String[] args) 
	{	/*
		字符串常量  用双引号括起来的内容
		整数常量  所有整数
		小数常量  所有小数
		字符常量  用单引号括起来的内容，里面只能放单个数字，字母或符号
		布尔常量  只有true 和false
		空常量  null
		*/
		System.out.println("abc");  //字符串常量
		System.out.println(123);    //整数常量
		System.out.println(12.3);   //小数常量
		System.out.println('a');     //字符常量
		System.out.println(' ');     //字符常量
		System.out.println(true);    //布尔常量
		System.out.println("");     //空常量null
	}
}

源码，反码，补码：

原码：
就是二进制定点表示法，即高位为符号位，“0”表示负，“1”表示正，其余位数表示数值大小。
通过一个字节，如8个二进制数表示+7和-7 ，00000111 ，10000111
反码：
正数的反码与原码相同，负数的反码是其源码逐位取反，但符号位不变
补码：
正数的补码与源码相同，负数的补码是其反码末位加1

变量：

数据类型：基本数据类型，引用数据类型

基本数据的分类
数值型	----------------------------
bite	占一个字节，-128-121
short	占2个字节，-2^15 - 2^15 -1
int	占4个字节，-2^31 - 2^31 -1
long	占8个字节
浮点型	------------------------------
float	占4个字节，单精度
double	占8个字节，双精度
字符型	---------------------------------
char	占2个字节0-655555
布尔类型	-----------------------------
布尔类型	理论上占1/8字节

变量类型如下：

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

	{
		//整数类型
		byte b = 10;   //占1个字节，-128到127之间
		short s = 20 ;  //占2个字节
		int i = 30;     //占4个字节  ,整数默认的数据类型就是int
		long x = 100000L ;         //占8个字节，可以在数字后面添加L表示 long（长整型）
		System.out.println(b);
		System.out.println(s);
		System.out.println(i);
		System.out.println(x);
		System.out.println(111+5658);

		//浮点类型
		float f = 12.3F;    //占4个字节   因为小数默认的类型是double，所以需要加F，避免精度减少
		double d = 36.9;  //占8个字节    小数默认的数据类型是double
		System.out.println(f);
		System.out.println(d);

		//字符型
		char c = 'a';  //字符型占两个字节
		System.out.println(c);

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

变量的注意事项：

class Demo2_Datatype {
	public static void main(String[] args) 
	{   
		/*
		a:作用域问题
			同一个区域内不能使用相同的变量名
		b:初始化问题
			局部变量在使用前必须赋值
		c:一条语句可以定义几个变量(先声明，后赋值)
			int a,b,c ...;
		*/

		int x = 1 ;
		//int x = 2 ;                //此处会报错，该变量名已经被赋值（此处指初始化）过了（python不存在这个问题）
		System.out.println(x);
		

		//int y ;                   //若声明了变量（不初始化变量，在使用之前是不会报错的）
		//System.out.println(y);    //这里会报错，还未初始化变量


		int a,b,c;
		a = 1;
		b = 2;
		c = 3;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);

		int d=4, e=5, f=6;
		System.out.println(d);
		System.out.println(e);
		System.out.println(f);
	}
}

变量的运算：

class Demo_yunsuan 
{
	public static void main(String[] args) 
	{
		System.out.println('a'+1);   //输出98   ，说明字符常量（不是字符串常量，单引号）可以根据阿斯克码转化成数字，
		System.out.println((char)('a'+1));  //输出b
		System.out.println("hello" + "a");  //helloa
		System.out.println("hello" + 'a'+ 1); //helloa
		System.out.println("5 +5 = " + (5+5)); // 5+5=10
		
		char c = 'a';
		System.out.println(c); //a
		char c1 = 97;
		System.out.println(c1); //也输出a

		//中文
		char c2 = '中' ;     //char 赋值只能用单引号
		System.out.println(c2);  //可以打出中文字符（不是字符串）（最多1个，因为char2个字节） 
		char c3 = 111;
		System.out.println(c3); //输出o，是阿斯克码对应数字的符号


		System.out.println(10/3);       //整数相除，结果之显示整数
		System.out.println(10/3.0);      //3.33333333
		System.out.println(14%5);        //取余，4
		System.out.println(-14%5);       //-4  ，正负号有取余符号的左边决定


		int j = 3;
		j++;
		System.out.println(j);  //输出4 (3+1)
		++j;
		System.out.println(j);  //输出5 (4+1)
		int k ;
		k = j ++ ;              //++在变量前，先取值再自增
		System.out.println(k);  //5  此时j变成6了，但是j把加1之前的值5赋值给k
		System.out.println(j);  //6  

		k = ++ j ;              //++在变量前，先自增再取值
		System.out.println(k);  //7   j加1之后变成7 ，并赋值给k
		System.out.println(j);  //7
		
		int x1 = 4;
		int y1 = (x1++) + (++x1) + (x1*10); //第一个小括号应该是4参与运算，x1自增至5；第二个小括号x1是自增至6后参与运算，结果为4+6+60=70
		System.out.println(y1);   //输出70


		byte x2 = 10;
		//x2 = x2 + 1 ;   //损失精度   
		System.out.println(x2);
	}
}

赋值运算符和关系运算符：

class Demo_Operator 
{
	public static void main(String[] args) 
	{
		//赋值运算符
		int a = 3 ;
		System.out.println(a);  //3

		a += 4;
		System.out.println(a);  //7

		a = a + 4;
		System.out.println(a);  //11

		a *= 2;
		System.out.println(a);  //22

		short s = 1 ;
		s += 1;   //自带强制运算符，把short变成int
		System.out.println(s);  //2

		System.out.println(s>1); //true
		System.out.println(1==2); //false
		System.out.println(2 >= 2); //true
		System.out.println(1!=2);//true

	}
}

逻辑运算符和位运算符：

class Demo1_Operator {
	public static void main(String[] args) 
	{	/*
		& , | , ^ , ~ 的用法
		&   与
		|   或
		^   异或
		~   按位取反
		*/

		//逻辑与 &
		int x = 10;	
		System.out.println(x > 5 && x < 11);  //true (用&&时与运算左边遇到false，就不会运算右边，&则会全部运算)
		System.out.println(x > 5 & x > 20);  //false

		
		//逻辑或 |
		System.out.println(x > 5 | x >20) ;  //true (|| 和| 的结果是一样的，当使用||时，只要左边有true，就不会右边的内容。|则会执行全部内容)

		//逻辑异或 ^  (符号两端相同则false，不同则true)
		System.out.println(x > 5 ^ x >6) ;  //false (true,ture)
		System.out.println(x > 5 ^ x >11) ; //true  (true,false)
		System.out.println(x > 11 ^ x >6) ; //true  (false,true)
		System.out.println(x > 11 ^ x >12) ; //flase (false,false)



		//位运算(二进制)
		System.out.println(6 & 3);  //2  就是二进制数逐为取与
		System.out.println(6 | 3);  //7
		System.out.println(6 ^ 3);  //5

		//逐位取反 （原属的补码取反，得到新的数的补码，再用这个补码得到新的数）
		System.out.println(~6);  //-7


		//一个数对另一个数位异或两次，该数本身不变
		System.out.println(5^10^10); //5
		System.out.println(5^10^5); //10

		
		System.out.println("====================================================================");
		
		//实现两个整数变量的变换，不需要第三方变量
		int x1 = 10;
		int x2 = 5;
		System.out.println(x1); //10
		System.out.println(x2); //5
		//需要第三方变量 （开发推荐方法）
		int temp = x1;
		x1 = x2;
		x2 = temp;
		System.out.println(x1); //5
		System.out.println(x2); //10

		//不需要第三方变量（面试推荐方法）
		x1 = x1 + x2 ;
		x2 = x1 - x2 ;
		x1 = x1 - x2;
		System.out.println(x1); //10
		System.out.println(x2); //5
		//或：
		x1 = x1 ^ x2;
		x2 = x1 ^ x2;
		x1 = x1 ^ x2;
		System.out.println(x1); //5
		System.out.println(x2); //10
	
		System.out.println("===============================================");

		/*
		<< : 左移，左边最高为丢弃，右边补齐0 
		>>:  右移，最高位是0，左边补齐0，最高位是1，左边补齐1
		>>>:  无符号右移，无论最高为是0还是1，左边补齐0
		* ： 最有效率算出2 * 8 的结果
		*/
		//左移
		System.out.println(12<<1);   //24
		System.out.println(12<<2);   //48  ，左移n位就是乘2^n
		System.out.println(-12<<2);  //-48
		//右移
		System.out.println(12>>1);  //6, 向右移动n位，就是除以2^ n 
		System.out.println(12>>2);  //3 
		System.out.println(-12>>1); // -6
		System.out.println(-12>>>1); // 2147483642
		System.out.println(12>>>1);  //6
		//最有效率算出2 * 8 的结果(不用转化两个二进制数)
		System.out.println(2<<3);   // 16

		System.out.println("===============================================");
		//三元运算符
		//（关系表达式）? 表达式1  ：表达式2；
		int x3 = 10;
		int y3 = 5;
		int z3 = (x3>y3) ? x3 : y3;
		System.out.println(z3);  // 10
		int z3_1 = (x3>y3) ? y3 : x3;
		System.out.println(z3_1);  // 5
		int z3_2 = (x3>y3) ? 1 : 2;
		System.out.println(z3_2);  //1 
		int z3_3 = (x3<y3) ? 1 : 2;
		System.out.println(z3_3); //2  ,即问号左边表达式若返回true，则运行冒号左边的内容，false则运行冒号右边的内容	
	} 
}

键盘录入：

import java.util.Scanner;
class  Demo_Input{
	public static void main(String[] args) 
	{	/*
		键盘录入数据步骤
		1.导包：
			格式：imput java.util.Scanner;
			位置：在class上面
		2.创建键盘录入对象：
			格式：Scanner sc = new Scanner(System.in);
		3.通过对象获取数据：
			格式：int x = sc.nextInt();
		*/
		Scanner sc = new Scanner(System.in);   //创建键盘录入对象
		System.out.println("请输入一个整数："  );
		int x = sc.nextInt(); 
		System.out.println(x);
		System.out.println("请输入二个整数："  );
		int y = sc.nextInt();
		System.out.println(y);

	}
}

IF 语句：

import java.util.Scanner;
class  Demo_If{
	public static void main(String[] args) {
		
		//if 语句
		int age = 20;
		if (age >= 18){
			System.out.println("可以浏览网站");
		}    //若if语句中的内容只有一条语句，可以省略大括号 。 if 语句的条件结果必须是布尔类型
		else {System.out.println("年龄不够");
		}
		

		//if 语句加键盘输入实例
		int y ;
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数y");
		y= sc.nextInt();
		if (y<5){
			System.out.println("y是小于5的数");
		}
		else if (y>=5 & y<=10){
			System.out.println("y是大于等于5小于等于10的数");
		}
		else {
			System.out.println("y是大于10的数");
		}
		

		// if 嵌套  (例，找最大值)
		int a = 10;
		int b = 12;
		int c =8;
		if (a>b){
			if (a>c){
				System.out.println("a是最大值");
			}
			else {
				System.out.println("c是最大值");
			}
		}
		else {
			if (b>c){
				System.out.println("b是最大值");
			}
			else {
				System.out.println("c是最大值");
			}
		}

		
		System.out.println("=================================");
		//switch   (主要是判断固定值，if是判断一个变化的区间)
		/*
		switch的格式
			int x = 10;
			switch{表达式}{                         //表达式中可以基本数据类型byte，short，int，char；应用数据类型 string字符串
			case 值1;
			语句体1;			
			break;
			case值2;
			语句体2;
			break;
			...
			default;
			语句体n+1;
			break;
			}
		
		计算流程：
		1 先计算表达式中的值
		2 和case后面匹配，如果有就执行对应语句，没有就执行default对应的语句
		*/
		
		String name = "张三";
		String gender = "男士";
		switch (gender){
			case "男士":
				System.out.println(name + "是一位" + gender);
			break;
			case "女士":
				System.out.println(name + "是一位" + gender);
			break;
			default :
					System.out.println("人妖");
			break;
			}

		//switch 的条件表达式值只能说常量，不能是变量，default可以省略。
		//switch 中default 可以放在任意位置，程序会先执行case，默认放在最后面
	}
}

for 循环：

class Demo_For 
{
	public static void main(String[] args) 
	{
		/*
		for （初始化表达式 ; 条件表达式 ; 循环后的操作表达式）
		{循环体;}

		程序执行流程：
		1.执行初始化语句
		2.执行判断条件语句，返回true或false。如果是true就继续，如果是false就结束循环
		3.执行循环体语句
		4.执行循环后的操作表达式
		5.返回第2步
		*/

		//例：输出十次helloworld
		for (int x = 1; x <= 10; x += 1 ){
			System.out.println("Hellow World");
		}


		//例：求出1-10之间的数据之和
		int x = 0;
		for (int i=1; i <= 10 ; i += 1 ){
			x += i ;
		}
		System.out.println(x); //55


		//例：求出1-100之间偶数之和
		int y = 0;
		for (int i = 1 ; i <= 100 ; i += 1 ){
			if (i  % 2 == 0){
				y += i;
			}
		}
		System.out.println(y);  //2550


		//例：找出1-999之间的水仙花数，各个位数的立方和等于原数
		System.out.println("========================================");
		for (int i =1;  i <=999 ; i +=1 ){
			int ge = i % 10;
			int shi = i /10 %10;
			int bai = i /100 % 10 ;

			if (Math.pow(ge,3) + Math.pow(shi,3) + Math.pow(bai,3)  == i ){
				System.out.println(i);     // 1 ,153,370,371,407
			}
		}

	}
}

continue 和 break：

class Demo_Break_Continue {
	public static void main(String[] args) {
		for (int x =1 ; x  <=10  ;  x++){
			if  (x==5){
				continue;           //本次循环结束，整个循环继续
			}
			
			else if (x == 8){
				break;             //整个循环都结束
			}
			else {
				System.out.println(x);      //打印了1 2 3 4 6 7
			// return ; 这里终止了整个方法（主方法）就不会运行循环外的语句了
			}
		}
		
		System.out.println("循环外的一句话");
	}
}

标号：

class Demo_Mark {
	public static void main(String[] args) {
		a : for (int x = 1;x <= 5 ; x ++ ){              //标号，可以用于跳出指定循环
			System.out.println(x);
			b : for (int y =6;y <= 10 ;y++ ){
				System.out.println(y);
				// break;   直接break只会打断最近的内循，不会打断外循环
				//break b;   //打断被嵌套的内循环，输出 1 ，6，2，6，3，6.。。   总共5*2 = 10 个数（执行5次外循环，每次外循环的时候内循只执行了一次）
				//break a ;     //只输出了1，6，外循环被打断了之后内循环也被打断了
				//如果没有break输出了（1+5）*5 = 30个数
				//标号的名称必须是合法的标识符（不能以数字开头）
			}
			
		}
	}
}

while 循环：

class Demo_While {
	public static void main(String[] args) {
		System.out.println("Hello World!");
		/*
		初始化表达式
		while (判断表达式){
		循环体语句；
		控制操作语句；
		}
		*/
		
		//例：输出1-10
		int x = 1;
		while (x <= 10){              
			System.out.println(x);  //循环体
			x ++;                       //控制操作语句（在循环体语句执行完之后执行）
		}
		

		//例：求1-100的和
		int sum = 0;
		int i = 1;
		while (i <= 100){
			sum += i ;
			i ++ ;
		}
		System.out.println(sum);  //5050

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


		//do while：  先执行一遍循环体，在进行条件判断
		/*
		初始表达式；
		do{
		循环体语句；
		控制条件语句；

		}
		while {判断条件语句}
		*/
		//例
		int j = 1;
		do
		{
			System.out.println(j);
			j ++;
		}
		while (j <= 10);  
		
		System.out.println("========================================");
		for (int a =1;a <= 10 ; a++ ){
			System.out.println(a);
		}
		//System.out.println(a);  这例报错，因为for循环的初始化表达式的变量是在循环内，所以循环结束后变量会被释放
		
	}
}

for ,while ,do while 循环的区别：
do while 相对于while 至少会执行一遍循环体
for 循环相对于while和do while ，初始化表达式在循环体内，所以循环结束后表达式中变量会被释放而不能调用（变量名可以用来重新声明，赋值）

方法：

class Demo_Function {
	public static void main(String[] args) {
		/*
		方法的格式：
		修饰符 返回值类型 方法名（参数类型 参数名1 ，参数类型  参数名2，。。。。）{
			方法体语句；
			return 返回值；
			}

			说明：
			修饰符：如public static 
			返回值类型：结果的数据类型
			方法名：符合命名规则即可‘
			参数：
					实际参数：实际参与运算的数据’
					形式参数：方法定义中用于接收实际参数的
			参数类型：
			参数名：
			方法体语句：需要执行的语句
			返回值：返回的结果
		*/

		int a =1;
		int b =2;
		int c = 3;
		int d = 4;

		int sum_ab = sum(a,b);
		int sum_cd = sum(c,d);
		System.out.println(sum_ab);  //3
		System.out.println(sum_cd);  //7

		int max_ab = max(a,b);
		System.out.println(max_ab); //2
	}
	
	public static int sum(int x ,int y ){                       //定义一个求和的方法sum
		int sum = x + y;
		return sum;
	}


	public static int max(int x ,int y){                      //定义一个输出两个数中更大的数的方法max
		if (x>=y){
			return x;
		}
		else{
			return y;
		}
	}


	public static int sum(int a , int b , int c){                                               //方法的重载，方法名相同，参数列表不同，与返回值类型无光
		return a+ b +c
	}                                                               //在调用这个方法时，因为参数列表不一样所以不会搞混


}

数组：

class Demo_Array{
	public static void main(String[] args) {
		/*
		数组是储存同一种数据类型多个元素的集合，也可以看成是一个容器，
		数组既可以储存基本数据类型，也可以储存引用数据类型
		数组定义的格式：
		数组类型 [] 数组名 = new 数据类型 [数组的长度];
		*/

		/*
		栈：储存局部变量，方法
		堆：储存new出来的数组和对象
		方法区：
		本地方法区：系统相关
		寄存区：给cpu使用的
		*/

		int [ ]  arr1 = new int [3];  //等号左边的中括号代表数组。几个中括号就是几维数组；等号右边 的中括号代表数组长度,new 是创建新的数组的意思
		System.out.println(arr1);  //打印的结果是地址值。这是动态初始化，在内存中开辟3个空间，数组内容是默认值
		arr1[0] = 0;
		arr1[2] = 5;
		System.out.println(arr1[2]);  //5
		System.out.println(arr1[1]);  //0   (没有赋值的位置就是默认值)


		//数组静态初始化
		//数组类型 [] 数组名 = new 数据类型 [] {元素，元素2，元素3，。。。};
		int [] arr2 = new int [] {1,3,2,5,4};       //不允许动态静态结合，即int后面的中括号里面不能写数组长度
		System.out.println(arr2[1]); //3
		//数组静态初始化的简写：
		int [] arr3 = {1,2,5,6,7};    //简写形式的声明和赋值必须在同一行
		System.out.println(arr3[3]);  //6
		//System.out.println(arr3[5]);  //   报错，越界异常
		arr3 = null;
		//System.out.println(arr3[3]);  //报错，空指针异常
		System.out.println("============================");


		//遍历
		int [] arr4 = {11,22,33,44,55};
		System.out.println(arr4.length);   //数组的长度为5
		for (int i = 0 ;i<=4 ; i++){
			System.out.println(arr4[i]);
		}

		//二维数组
		int [] [] arr5 = new int [3] [2] ;   //表示这个数组中有3个一维数组，每个一位数组中有2个元素  （这和矩阵的概念相反）
		// int [] x,y[]   ,这里x是一位数组（一个中括号），y是二维数组（两个中阔哈）
		// int [] x [] ,二维数组的声明
		System.out.println(arr5);        //二维数组的地址
		System.out.println(arr5[0]);   //二维数组中的第一个一维数组的地址
		System.out.println(arr5[0][0]);  //二维数组中第一个一维数组中的第一个元素，默认值 0

		System.out.println("============================");
		//例1
		bianLi(arr4); //调用建立的遍历方法，打印 11，22，33，44，55  
		//例2
		System.out.println(findMax(arr4));  //55   调用找最大值的方法
		//例3
		int [] arr4_inverse = inverse(arr4);  //调用转置方法
		bianLi(arr4_inverse);   //遍历打印转置后的数组，打印 55，44，33，22，11

	}
	
	//建立一个遍历数组的方法
	public static void bianLi(int [] arr){
		for (int j =0 ;j < arr.length ; j ++){
			System.out.println(arr[j]);
		}
	}

	//建立一个找数组中最大值的方法
	public static int findMax(int [] arr){
		int max = 0;
		for (int i = 0; i< arr.length ; i ++){
				if (arr[i] >= max ){
					max = arr[i];
				}
		}
		return max;
	} 


	//建立一个转置数组的方法
	public static int [] inverse(int [] arr){
		int [] arr_inverse = new int [ arr.length];
		for (int i = 0; i < arr.length;i ++ ){
			arr_inverse[arr.length-i-1]  = arr[i];
		}
		return arr_inverse;
	}

}

面向对象：

对象（现实，特殊的某个）-类（抽象，一类的）
类：1，属性；2，方法

class Demo_Object_Student {
	public static void main(String[] args) {
		//创建对象的格式： 类名 对象名 = new 类名()
		//对象名：其实就是合法的标识符，如果是一个单词，所以单词小写，如果是多个单词，第二个单词开始首字母大写
		//使用成员变量：对象名.变量名
		//使用成员方法：对象名.方法名（）
		
		Student st1 = new Student ();            //新建一个学生对象
		st1.name = "张三";                           //给学生对象的变量赋值
		st1.age = 22;
		st1.gender = "男";
		System.out.println(st1.gender);          //查看对象的变量值
		st1.study() ;                                      //使用对象的方法
		st1.sleep();

	}
}

/*
A:案例演示：学生
	属性：姓名，年龄，性别
	方法（行为）：学习，睡觉
B：如何描述现实世界事物
	属性：就是该事物的描述信息
	行为：就是该事物能做什么
C：Java中最基本的单位是类，用类描述事物也是如此
	成员变量：就是事物属性
	成员方法：就是事物的行为
D：定义类其实就是定义类的成员（成员变量和成员方法）
	成员变量： 在类中，方法外
	成员方法 ：没有 static
*/

class Student{
	String name;     //属性 姓名
	int age ;           //属性  年龄
	String gender;  //属性  性别

	public void study() {
		System.out.println("学生学习");    //定义学习方法
	}
	public void sleep() {
		System.out.println("学生睡觉");     //定义睡觉方法
	}
}

//在一个Java文件中可能有测试类（有主方法的，程序入口）和基本类（如学生）两个类，而文件名最好是和测试类相同。

成员变量和局部变量：
成员变量在类中，方法外
局部变量在方法定义中或方法声明上