总结-第一阶段-第二周

if…else…格式和三元运算符的区别

三元运算符只是一个运算符号,不是流程控制语句,在三元中不能输出打印值,可以操作具体的数据值(结果最终是数据值)。而if…else…流程控制语句,范围远远大于三元运算符既可以使用具体数据值,也可以是打印内容;

switch语句

switch语句格式

	switch(表达式){
		case 值1:
				语句1;
				break ;  
		case 值2:
				语句2;
				break ;
		...
		default:
				语句n;
				break ;
		}
执行流程:
1)表达式中的值先和case值1比较,如果匹配,执行语句1,语句break,语句结束;
2)case值1不匹配,继续和case值2进行比较,如果一致,执行语句2,swich结束;
3)如果上面的case的值和表达式中的结果值都不匹配,执行default语句,执行语句n,switch语句结束;		

switch语句使用的注意事项

		1)case语句里面是有break,
			如果没有书写break,会造成"case传统"
		2)case语句后面的值只能是常量值,不能是变量值
			(Java是一个强类型语言:语法结构很严谨)	
		3)关于default语句	
			它可以在语句中的任何位置,不影响switch语句的执行流程!
			但是如果在语句中,那么break不要省略!(考点)
			如果default语句它在语句的末尾,break可以省略
			
		4)switch语句的结束条件:
				
			1)语句break结束
			2)程序默认执行到末尾!(顺序结构语句都是依次由上而下,末尾结束

1、case语句后面的值只能是常量值,不能是变量值
2、default语句，它可以在语句中的任何位置,不影响switch语句的执行流程。如果default语句它在语句的末尾,break可以省略。但是如果在语句中,如果没有书写break,会造成"case穿透"，优先匹配case，此时若没有break，则会按顺序依次执行后面的代码，直到遇到break

    switch(3){    //匹配case 3 
    	case 1:	
    		System.out.println("星期一") ;
    	break ;
   		case 2:
   	 		System.out.println("星期二") ;
    	break ;
    	case 3:
			System.out.println("星期三") ;		//依次执行后续代码输出
		case 4:
			System.out.println("星期四") ;
		case 5:
			System.out.println("星期五") ;
		default:
			System.out.println("您输入的数据非法!") ;
				}

for循环

for循环基本格式

	for(初始化语句;条件表达式;控制体语句或步长语句){
		循环体语句;
		}
	for(int x = 1; x<=5 ; x++){
			System.out.println("循环体语句")
		}
执行流程:
1、先初始化语句进行赋值
2、判断条件表达式是否成立,如果成立,执行循环体语句
3、继续执行控制台语句或者步长语句  对初始化语句的变量进行自增或者自减
4、继续判断条件表达是否成立,如果成立,按照上面 这种方式执行;
5、如果变量自增或者自减到条件表达式不成立为止,循环语句结束!

for循环的嵌套

for循环的嵌套基本格式
		for(初始化语句;条件表达式;控制体语句){
			for(初始化语句2;条件表达式2;控制体语句2){//循环体---就是内层for循环
				内层循环的循环体...
			}
		}

for循环—水仙花数

水仙花数指的是三位数,而且这个三位数每个位上的数据的立方之和是它本身。

如153=1x1x1+5x5x5+3x3x3

	class ForTest3{
		public static void main(String[] args){
		int count = 0 ;   //定义统计变量
		for(int x = 100;x<=999; x++){//水仙花,三位数--for循环
			//定义三个变量:ge,shi,bai 
			int ge = x % 10 ; // 153 %10 =3    %(求余数)
			int shi = x /10%10 ; // 153 /10%10 = 5
			int bai = x /10/10 %10 ; //153 /10/10%10 = 1
			if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){//如果当前x就是ge*ge*ge+shi*shi*shi+bai*bai*bai,输出x
				count ++ ;
				System.out.println("第"+count+"次的水仙花数是:"+x) ; 
				}
			}
	System.out.println("水仙花数共有:"+count+"个");
		}
	}

for循环练习

请在控制台输出满足如下条件的五位数
个位等于万位
十位等于千位
个位+十位+千位+万位=百位
	class Test3{
	public static void main(String[] args){
		System.out.println("满足条件数据是:") ;
		for(int x = 10000 ; x<=99999; x++){
			int ge = x % 10 ;
			int shi = x /10 %10 ;
			int bai = x/10/10 % 10 ;
			int qian = x/10/10/10 %10;
			int wan = x/10/10/10/10 %10;
			if((ge==wan) && (shi==qian) && ((ge+shi+qian+wan)==bai)){
				System.out.println(x) ;
			}   }   }   }
			

(循环）输入一个整数，计算它各位上数字的和。（注意：是任意位的整数）
	import java.util.Scanner ;
	class Test5{
		public static void main(String[] args){
		int sum = 0 ;//定义最终结果变量
		Scanner sc = new Scanner(System.in) ;	//创建键盘录入对象
		System.out.println("请输入一个数据n:");//提示并录入数据
		int n = sc.nextInt();
		while(n!=0){
			sum = sum + n%10 ;//获取低位
			n = n /10 ;	//去除低位
		}
		System.out.println("任意位整数的各个位上的和是:"+sum) ;
	}  }
键盘录入一个正整数x，判断该数是否为一个质数
质数:除了1和他自身外,不能被其他数据整除的
如果录入的数据开平方根,这个不适用于过大的整数!(范围较小)	
	import java.util.Scanner ;
	class Test6{
	public static void main(String[] args){
		

		Scanner sc = new Scanner(System.in) ;//创建键盘录入对象
		System.out.println("请输入一个数据x:") ;	//提示并录入数据
		int x = sc.nextInt() ;
		boolean flag = true ;	//定义变量flag,判断是否为质数,true:质数,false:不是质数
		if(x < 2){
			flag = false ;
		}
		for(int i = 2 ; i<=Math.sqrt(x);i++){ //录入的数据开平方根
			if(x % i ==0){
				flag = false ;
			}
		}
		if(flag){
			System.out.println("是质数");
		}else{
			System.out.println("不是质数");
		}	} 	}
1-100的质数和。除过1和他自身外,不能被数据整除的
	import java.util.Scanner ;
	class Test{
	public static void main(String[] args){
		System.out.println("请您输入一个数据n:") ;
		int n = sc.nextInt() ;
		int sum = 0 ;
		for(int x = 2 ; x<=n ; x++){
			for(int y = 2;y<=x; y++){	//内层循环:需要使用x的数据对y数据进行模%
				//满足条件
				if(x % y == 0 && x !=y){
					break ;
				}
				if(x % y == 0 && x==y){
					//质数
					sum = sum + x;
				}
			}
		}
		System.out.println("范围"+n+"以内的质数之和是:"+sum) ;
	}
}

穷举问题：百钱买百鸡

公鸡5文钱一只，母鸡3文钱一只，小鸡1文钱3只，如何使用100文钱买到一百只鸡
	class Test{
	public static void main(String[] args){
		//定义三个变量
		//分别代码公鸡,母鸡,小鸡的数量
		//x:公鸡
		//y:母鸡
		int z = 0 ;
		for(int x = 0 ; x <= 20 ; x++){//公鸡的数量
			for(int y = 0 ; y <= 33; y ++){	//母鸡的数量
				z = 100 - x - y ;//小鸡的数量
				if((5*x+3*y+z/3)==100 &&  (z%3==0)){//满足条件:100文件同时公鸡,母鸡,小鸡
	System.out.println("公鸡的数量是:"+x+"只,母鸡的数量是:"+y+",小鸡的数量是:"+z) ;
			}
		}
	}

while 循环

while循环基本格式

基本格式：
	while(条件表达式){
			循环体语句;
			控制体语句或者步长语句;
		}
扩展格式:(使用多)
		初始化语句:
		while(条件表达式){
			循环体语句;
			控制体语句或者步长语句;
		}
执行流程:
1)初始化语句进行变量赋值
2)判断条件表达式是否成立。成立,执行循环体语句,依次执行控制体语句(对变量控制)继续进行判断
3)条件表达式不满足,循环结束

while实现水仙花数

	int count=0;
	int i=100;
	while(i<=999){
	int ge= i%10;
	int shi= i /10 %10;
	int qian= i/100 %10;
	if(i==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
		count++;
		System.out.println("第"+count+"次的水仙花是:"+i)
		}
		i++;
	}System.out.println("共有"+count+"个") ;

猜数游戏

键盘录入int类型的数据，猜数字游戏（1-100之间的数据）

jdk提供一个类java.Lang.Math（不需要导包）：数学运算的工具random（），这个函数可以获取  [0.0 ， 1.0）的随机数
	int number = (int)(Math.random()*100+1);
	System.out.println("猜数字游戏开始...");
	int count=0;
	while(true){
		count++;
		Scanner sc = new Scanner(Syetem.in);
		System.out.println("请输入要猜的数据...");
		int guessNumber = sc.nextInt();
		if(guessNumber<1 || guessNumber>100){
				System.out.println("您输入的数据不合法!") ;
			}else if(guessNumber > number){
				System.out.println("您要猜的数据"+guessNumber+"大了") ;
			}else if(guessNumber < number){
				System.out.println("您要猜的数据:"+guessNumber+"小了") ;
			}else{
				System.out.println("恭喜您,第"+count+"次,猜对了!") ;
				break  ;//满足条件,结束死循环
			}
	}

while 和 for 的区别

共同点：都是使用循环思想解决一些问题
不同点:
	1)格式本身不同
	for(初始化语句;条件表达式;控制体语句){
		循环体语句;
		}
	初始化语句;
	while(条件表达式){
		循环体语句;
		控制体语句;
		}
2)是否明确循环次数
	for循环:明确循环次数优先for循环
	while循环:不明确循环次数,使用while循环
3)从内存角度考虑销毁不同:
	for循环结束,里面的变量及时释放了,所以不能在访问for中的变量
	whlile循环结束,依然可以访问里面变量,所以消耗资源相对for循环大一些
常见的两种死循环格式
		for(;;){	
			循环体...	
		}
		while(true){ 
			循环体...
		}

do-while 循环

格式
	初始化语句;
		do{
			循环体语句;
			控制体语句;
		}while(条件表达式) ;    
执行流程:
1)初始化语句进行赋值
2)执行循环体语句---控制体语句---完成条件判断
继续判断,当条件不满足,循环结束
如果条件直接不满足,循环体至少执行一次。这也是for/while最大的区别

跳转控制语句-break

break:结束中断的意思
两种应用场景:
		1)循环语句中使用,结束循环用的
		2)switch语句中使用,结束switch
		不能单独使用,不能脱离上面两种场景
早期使用:break 标签名称; 	结束指定的循环	
 	在for循环嵌套中,给for循环的前面加上一个 "标签名称:"
			 wc:代表外层循环
			 nc:代表内层循环
			 wc:for(初始化语句;条件表达式;控制体语句){
				 nc:for(初始化语句2;条件表达式2;控制体语句2;){
					 循环体;
					 //当达到我指定的条件,
					 break wc;//结束外层循环了
				 }
			 }
	wc:for(int x = 0 ; x < 5 ; x ++){ 
			nc:for(int y = 0 ; y <6 ; y ++){
				if(x==3){
					break wc;//结束外层循环
				}
				if(y==3){
					break nc; //结束内层循环
				}
				System.out.print("*") ; 					
			}
			System.out.println();
		}			

跳转控制语句-continue
continue:继续执行(结束当前循环,立即进入下一次循环)，不能单独使用
		for(int x = 1 ;x<=10;x++){	 //continue 在 loop 外部 (仅仅在循环语句中使用)
			if(x==4){
				continue ;//continue:继续执行(结束当前循环,立即进入下一次循环)
			}
			System.out.println(x) ;//输出1235678910
		}

跳转控制语句-return

很少单独去使用,后面一般都会有返回结果值。

return应用场景:在Java中的方法(函数)中去使用,目的就是结束这个方法,并且还有返回结果

Java中的方法(函数)

方法:就是一个代码块{},给{}起一个名字(方法名),然后方法中逻辑书写(根据你的实际需求)。以后见到同样一个功能代码块,直接调用方法名即可。

Java中定义方法的格式:
		1)有返回值类型的方法的定义
		public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参数名2...){
			//完成方法的逻辑
			return 结果;
		}
格式说明
    前面固定public static 
    返回值类型:也就是数据类型
    方法名:就是满足标识符的命名规则:见名知意 (小驼峰命名法)
    形式参数类型:也是数据类型
    参数名:就是变量名
有返回值类型的方法如何调用呢
    1)单独调用 ---方法名(实际参数列表) ; (有返回类型的方法不能使用)
    2)输出调用 ---System.out.println(方法名(实际参数列表)) ;
    输出调用:可以,写死了,如果相对结果值在进行操作,就不能用了
    3)赋值调用:(推荐)
在Java中有返回值类型的方法的定义以及调用格式中注意事项:
		1)方法和方法平级关系,不能在一个方法中去定义另一个方法!
		2)定义方法的返回值类型和main方法中调用方法的时候,接收结果类型不匹配
		3)Java是强类型语言,在定义的方法时候,形式参数名前面必须有参数类型
		4)	必须有return语句,没有就会编译报错	
		5)定义方法的时候,有{号地方不能有分号;有分号;,不能有{左大括号
定义一个方法:求三个数据中的最大值
定义方法两个明确
	明确返回值类型  int
	明确参数类型以及参数个数   int,3个
	public static int  getMax(int a,int b,int c){
			int max ;
			if(a>b){
				if(a>c){
					max = a;
				}else{
					max = c;
				}
			}else{
				if(b>c){
					max = b ;
				}else{
					max = c ;
				}
			}
			return max ;
	}

没有返回值类型的方法定义格式

没有返回值类型的定义格式:
	按照正常方法定义(遵循有返回值类型的格式)
	public static 返回值类型 方法名(形式参数类型1 参数名1,参数类型2 参数名2...){
		
		方法逻辑体...
		return 结果;
		}
Java规定,当方法没有具体返回值的时候,需要使用"void"充当这个 "返回值类型"这个格式,
没有返回值类型的方法体中{}里面,就应该直接打印或者完成一些其他业务(数据交互)...
没有具体返回值类型的方法的定义格式:(没有return语句)
调用方法:
	1)赋值调用和输出调用 都使用不了
	2)推荐:单独调用

需求:使用方法来完成打印4行5列的*形
class FunctionDemo{
	public static void main(String[] args){
		printStar(5,6) ;
	}
	public static void printStar(int m,int n){//m行数,n列数
		for(int x = 0 ; x < m ; x++){
			for(int y = 0 ; y < n ; y ++){
				System.out.print("*") ;
			}
			System.out.println() ;
		}  }  }

方法的形式参数问题

方法的形式参数如果是基本数据类型,形式参数的改变不影响实际参数
方法的形式参数如果是引用数据类型(数组,类,接口),形式参数的改变会直接影响实际参数
String类:字符串,它是一个特殊的引用类型,它作为形式参数传递,和基本类型作为形式参数效果一致!
基本数据类型:不需要被jvm加载	(校验语法格式-->编译时期)
用数据类型:类,数组,接口
class Student{} ---->被jvm加载 (需要编译---运行时期)
	class ArgsDemo{
	public static void main(String[] args){
		int a = 10 ;
		int b = 20 ;
		System.out.println("a:"+a+",b:"+b) ;
		changeValue(a,b) ;
		System.out.println("a:"+a+",b:"+b) ;//a:10,b:20
		System.out.println("--------------------------------") ;
		int[] arr = {1,2,3,4,5} ;
		System.out.println(arr[1]) ;//2
		changeValue(arr) ;
		System.out.println(arr[1]) ;//4
	}
	public static void changeValue(int a,int b){//形式参数基本类型
		a = b ;   //a = 20 
		b = a + b ;//b = 20 + 20 = 40 
		System.out.println("a:"+a+",b:"+b) ;//20,40
		
	}
	public static void changeValue(int[] arr){//形式参数:引用类型 数组,(实际参数传递是数组地址值)
		for(int x= 0 ; x < arr.length; x++){
			if(arr[x] % 2 ==0){
				arr[x] *=2 ;
			}}}}

	class ArgsDemo2{
		public static void main(String[] args){
			String s = "helloworld" ;
			System.out.println(s) ;//地址
			changeValue(s) ;
			System.out.println(s) ; //"helloword"
		}
		public static void changeValue(String str){//str=s="helloworld"
			str += "JavaEE" ;//str = "helloworldJavaEE"
			System.out.println(str) ;//"helloworldJavaEE"
		} }

方法重载

方法：重载方法名相同,参数列表不同,和返回值无关
参数列表不同: 1)参数个数不同 2)参数类型不同 3)参数类型顺序
重载的意义:提高功能扩展性(一个方法中可以传递任何类型参数)

方法调用流程

数组

数组定义格式

数组定义以及初始化
定义格式:	
	1)数据类型[] 数组名称;
	2)数据类型  数组名称[] ;
		举例:
			int[] arr;  定义一个int类型的数组arr
			int arr[] ; 定义一个int类型的arr数组
初始化:
1)动态初始化
	给定数组长度,系统(jvm)默认分配数组元素内容;
		格式:
			数据类型[] 数组名称 = new 数据类型[数组长度] ;
			数据类型  数组名称[] = new 数据类型[数组长度] ;
		举例:
			int[] arr  = new int[3] ;
						在数组如何确定元素的内容
						数组名称[索引值(角标值)]:从0开始
2)静态初始化
给定数组元素,长度由系统给定
	原本格式：
		数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
		数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;	
	简写格式：
		数据类型[] 数组名称 ={元素1,元素2,元素3....} ;
		数据类型 数组名称[] = {元素1,元素2,元素3....} ;
		举例:
			int[] arr = {1,2,3} ;
	注意事项:
		不能既动态初始化,又静态初始化(动静结合)
		int[] arr  = new int[3]{1,2,3} ;//错误			
数组在内存存储必须是连续的		

class ArrayDemo{
	public static void main(String[] args){
		int a = 10 ;//基本类型
		//创建一个数组:动态初始化
		//数据类型[] 数组名称 = new 数据类型[数组长度] ;
		int[] arr = new int[3] ;
		//int[] :定义一个int类型的数组
		//arr:变量名(满足标识符的规则) arr变量(数组名称arr)
		//new:在堆内存中开辟空间(创建对象)
		//int[]:在堆内存中创建一个int类型的数组
		//3:在堆内存中创建数组,长度为3
		System.out.println(arr) ;//[I@6d06d69c  :理解为"地址值" 
								//[:表示是一个数组
								//@:地址值标记
								//6dxxx 具体十六进制转			
		//在数组如何确定元素的内容
		//数组名称[索引值(角标值)]:从0开始
		System.out.println(arr[0]) ;//第一个						
	    System.out.println(arr[1]) ;//第二个
		System.out.println(arr[2]) ;//第三个
	}
}

创建一个数组对象的内存分析

创建多个数组对象内存分析

遍历数组

	public static void printArray2(int[] array){
		System.out.print("[") ;//1)先输出左中括号
		for(int x = 0 ; x < array.length;x++){	//2)遍历array中所有元素
			if(x==array.length-1){//如果当前角标x 取到了最大索引值,应该将最后一个元素并且,拼接一个右中括号
				System.out.println(array[x]+"]") ;//换行并输出
			}else{
				//中间的元素:  元素1, 元素2, 元素3, ...  (同一行上)
				System.out.print(array[x]+", ") ;
			}	}   }

数组逆序

定义一个数组：int a[] = {9,15,3,1,7,2},将数组进行逆序
(结果是[2,7,1,3,15,9]),编写一个方法完成 
	public static void reverseArray(int[] array){
		for(int x = 0 ; x < array.length/2 ; x++){
			//使用中间变量交换
			int temp = array[x] ;
			array[x] = array[array.length-1-x] ;
			array[array.length-1-x] =  temp ;	
		}
	}

数组最小值问题

	public static int getArrayMax(int[] arr){
		int max = arr[0] ;//定义一个参照物
		for(int x = 1 ; x < arr.length ; x++){	//遍历其他元素
			if(arr[x]> max){	//使用arr[x]和max进行对比
				max = arr[x] ;		//改变max的值
			}
		}
		return max ;
	}
}

数组的元素查询表法

需求:键盘录入一个数据,输出对应的星期值
分析:
定义一个字符串数组
数据类型[] 数组名称=  {元素内容} ;
String[] strArray =
{"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
	import java.util.Scanner ;
	class ArrayDemo{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in) ;
		System.out.println("请输入一个数据(0-6):") ;
		int weekValue = sc.nextInt() ;
		String[] strArray =
		{"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
		System.out.println("你要查询的是:"+strArray[weekValue]) ;
		}
	}
数组的基本元素查找查询数组中元素第一次出现索引值
  已知:
	int[] arr = {25,67,13,66,89,76} ;
	class ArrayDemo2{
	public static void main(String[] args){
		int[] arr = {25,67,13,66,89,76} ;
		int index = getIndex(arr,13) ;
		System.out.println("index值是:"+index) ;
		System.out.println("----------------------------------") ;
		int index3  = getIndex2(arr,87) ;
		System.out.println("index3:"+index3) ;
	}
假设思想
1)定义一个 int index = -1; 找不到
2)遍历arr数组,获取到每一个元素
2.1)判断 arr[x] == target,找到了
2.2)修改index的值(重新赋值) index =  x ;
2.3)break;
3)循环一圈都没有找到,
rturn index ;
	public static int getIndex2(int[] arr,int target){
			int index = -1 ;
			for(int x = 0 ; x < arr.length ; x++){
				//判断 如果arr[x]就是target
				if(arr[x] == target){
					index = x ;
					break ;
				} 
			}
			return index ;
	}

数组高级排序算法之:冒泡排序

思想:两两比较,将大的值往后方法,第一次比较完毕,最大值出现在最大索引处
	for(int x = 0 ; x < arr.length-1;x++){//比较的次数
			//里面元素进行比较
			//x=0:第一次有0个不比
			//x=1:第二次有1个不比
			//x=2:第三次有2个不比
			//x=3:第四次有3个不比
			for(int y = 0 ; y < arr.length-1-x;y++){//y数组角标
				//如果前面的元素比较后面大
				if(arr[y]> arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}

面向对象

面向对象思想特点:

​ 1)更符合生活中的思想行为习惯!
​ 2)让复杂的事情简单化!
​ 3)让我们从执行者变成指挥者!(角色变化)

面向对象设计理念：不断去创建对象,指挥对象做事情。

面向对象的特征：封装、继承、多态

创建一个对象内存图解

创建多个对象内存图解

局部变量和成员变量的区别

区别:
1)类中的书写位置不同
	成员变量:在类中,方法外
	局部变量:在方法定义中或者方法声明上
2)jvm内存位置不同
	成员变量:在堆内存中
	局部变量:在栈内存中
3)生命周期不同:
	成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完等待垃圾回收器回收(不会立即回收)而消失
	局部变量:随着方法调用而存在,随着方法调用结束而消失
4)初始化值不同:
	成员变量:存在系统默认初始化,也可以显示初始化
	局部变量:总之:在使用局部变量之前,必须赋值,不赋值不行
	class Variable{
	int num ; //成员变量，系统默认初始化就是0
	public void show(String y){ //y 局部变量
		//int x = 100 ; //x  局部变量
		System.out.println(x+y) ;
	}  }	

类和事物

类: (是Java中最基本单元)类是描述现实世界"事物"的一组"属性"和"行为"的集合!
成员方法(去掉static):和方法定义方法格式一样 study():			 
事物:一个类型的总称---描述具体的事物  
学生事物                ----->具体事物                       
  属性:姓名,年龄,性别            张三,20,男
  行为:学习                     正在学习JavaEE

  具体事物-----代码中体现--------->创建一个对象
  创建对象的格式:
          类名 对象名 = new 类名() ;
           对象名.成员变量名 = 值; (跟成员变量类型一致); 
           对象名.方法名() ;调用方法,展示这个具体事物有什么功能

封装

封装：将一个事物的属性私有化(对外界隐藏,private)—>保证数据的安全性
对外提供公共的成员访问方法:setXXX(传参)/getXXX(),来对成员属性进行操作!

private关键字

1)被private修饰的成员变量/成员方法(非静态),只能在本类中访问,外界类不能访问
2)虽然被私有修饰的成员变量以及成员方法(非静态)不能直接访问,但是都可以间接的通过"public"公共访问访问	
class Demo{
	//成员变量:类中方法外
	public int num = 10 ;
	private int num2 = 20 ;
	//定义一个公共的方法
	public void show(){
		System.out.println(num) ; //10
		System.out.println(num2) ;//20
	}
	//私有的成员方法
	private void function(){
		System.out.println("function Demo") ;
	}		
class PrivateDemo{                     
	public static void main(String[] args){
		Demo d  = new Demo() ;
		System.out.println(d.num) ;
		System.out.println(d.num2) ; //num2 在 Demo 中是 private 访问控制
		//d.function() ; // function() 在 Demo 中是 private 访问控制，不能访问
		}   }

this关键字

构造方法

构造方法: 1)方法名和类名一致 2)没有具体返回值类型 3)连void都没有 。 构造方法是可以重载

构造方法的作用:
给类的成员进行数据初始化
注意事项:
1)一个类中,如果没有任何构造方法,那么系统(jvm)自动会给我们提供无参构造方法!
2)一个类中,只提供有参构造方法,那么系统不会无参构造方法,此时,建议我们永远给出无参构造方法

this关键字：加入this，局部变量给成员变量赋值。哪个对象调用this指的就是哪个对象，代表地址
无参构造方法
	public Student(){
		System.out.println("这是Student的无参构造方法") ;
	}
带有一个String类型的参数的构造方法
	public Student(String name){ //姓名:局部变量---成员变量
		System.out.println("这是一个带有String参数的构造方法") ;
		this.name = name ; //加入this:局部变量给成员变量赋值
	}

一个标准类的写法

类的成员
	成员变量:属性私有化
	成员方法:公共访问setXXX(xx)/getXXX()
	构造方法:无参构造方法，永远给出 。有参构造方法

学生类
需求: 学生类(学生类的标准类的写法格式):姓名,年龄
     行为:学习,玩游戏
	public class Student {
   	 private String name ; //姓名
   	 private int age ; //年龄
 	 // 构造方法:
    public Student(){}  //无参构造方法
    //有参构造方法:局部变量给成员变量赋值
    public Student(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    //setXXX(xx)/getXXX()公共访问方法
    //给姓名赋值
    public void setName(String name){
        this.name = name ;
    }
    //获取姓名
    public String getName(){
        return  name ;
    }
    //给年龄赋值
    public void setAge(int age){
        this.age = age ;
    }
    //获取年龄
    public int getAge(){
        return  age ;
    }
    //其他成员方法
    public void study(){
        System.out.println(name+"正在学习如何书写Java中的标准类");
    }
    public void playGame(String gameName){
        System.out.println(name+"会玩"+gameName);
   	 }
	}