小白初学Java成长笔记

Edipse编译器问题

没有显示运行界面的处理方法

没有显示左边文件目录的处理方法

Java入门语法：

输出语句

package project1;

public class Hello {//Hello是类名，类名必须和文件名一致，
	//花括号必须匹配，也就是说有几个左括号就有几个右括号

	public static void main(String[] args) {//程序的入口，叫主方法或主函数，
		//程序要执行的代码都要放在这个方法中
		//在下面编写代码
		System.out.println("111111111");//输出语句，双引号中的内容表示要输出的内容，
		//要输出内容只能改变双引号中的内容
		System.out.print("2222222222");//输出语句，输出后不换行
		System.out.println("3333\n33333");//输出语句，遇到\n自动换行
	}

}

整除问题

public class MainClass {

	public static void main(String[] args) {
		int a1=1/2;//当/左右两边都是整数时，它所进行的是整除运算，即运算的结果只保留运算值的整数部分
		double a2=1/2;
		double a3=1.0/2;
		System.out.println(a1);
		System.out.println(a2);
		System.out.println(a3);
		
		int b=10%3;
		System.out.println(b);
	}

}

自加自减问题

//先加：++x：先进行x=x+1后 ，再进行其他操作，比如与y比较：x==y。
//后加：x++：先进行其他操作比如与y比较x==y，再进行x=x+1。
public class MainClass2 {
	public static void main(String[] args) {
		int x=8;
		int y=9;
//		System.out.println((++x==y)&&(++x!=y));
//		//(++x==y)等价于x=x+1;x==y;执行完x=9,y=9
//		//(++x!=y)等价于x=x+1;x!=y;执行完x=10,y=9
//		System.out.println(x);
		System.out.println((++x==y)||(++x!=y));
		//(++x==y)等价于x=x+1;x==y;执行完x=9,y=9
		System.out.println(x);
	}
}

强制类型转换

public class Ex2 {

	public static void main(String[] args) {
		int i=1;
		long l=2;
		
		l=i;//精度低的值能直接赋值给高精度的变量
		//i=l;//错误，精度高的值不能直接赋值给低精度的变量
		
		i=(int)l;//强制把l转换成整型赋值给i
		
		int ii=23;
		float ff=348888888888888f;
		//ff=ii;
		ii=(int)ff;
		System.out.println(ii);
		System.out.println(ff);
		
		double ddd=23;
		float fff=34.0f;
		fff=(float)ddd;
	}

}

从键盘进行输入

import java.util.Scanner;
public class MainClass3 {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);//input可以改为其它名称，如果改为其它名称，后面的input也要对应改为相同的名称
		String str=input.next();//从键盘输入一个字符串存放在str中
		System.out.println(str);
		int i=input.nextInt();//从键盘输入一个整数存放在i中
		System.out.println(i);
		double d=input.nextDouble();//从键盘输入一个数存放在d中
		System.out.println(d);
		input.close();
	}
}

常量的定义

public class FinalClass {
	public static void main(String[] args) {
		final double PI=3.14159;//定义常量
		//PI=233;//错误，不能对常量赋值
		double r=2;
		System.out.println(PI*r*r);
	}
}

比较字符串的方法

import java.util.Scanner;

public class MainClass9 {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		String name=in.next();
		System.out.println( name.equals("admin"));   
		//字符串变量名.equals("要比较的字符串")，判断字符串变量的值是否等于“要比较的字符串”，如果是，该方法的值（可理解成表达式的值）等于true,否则得到false
		//例如 String str="hello", boolean f=str.equals("hello"); f的值为true
		//     String str="hello", boolean f=str.equals("World"); f的值为false               
		if(      name.equals("admin")   ) {//理解成name=="admin"
			System.out.println("正确");
		}
	}

}

Switch语法解释

import java.util.Scanner;

public class MainClass5 {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
//		if(n==1) {
//			System.out.println("新增DVD");
//		}else if(n==2) {
//			System.out.println("查看DVD");
//		}else if(n==3) {
//			System.out.println("删除DVD");			
//			
//		}else {
//			System.out.println("输入错误");
//		}
		

		switch(n){//（）里面写if条件表达式中的变量名
		   case 1://当n==1时，执行冒号后面的内容
			      System.out.println("新增DVD");
		          break;//跳到switch外面执行
		   case 2://当n==2时，执行冒号后面的内容
			      System.out.println("查看DVD");
		          break;
		   case 3://当n==3时，执行冒号后面的内容
			      System.out.println("删除DVD");	
		          break;
		   default://当不满足上面条件时，执行冒号后面的内容
			      System.out.println("输入错误");
		}

		
		input.close();
	}

}

Switch案例

import java.util.Scanner;

public class SwitchDemo2 {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
//		int r=input.nextInt();
//		switch(r){
//		   case 1://用r=1表示第一名
//		           System.out.println("可以参加夏令营");
//		           
//		   case 2:
//			   	   System.out.println("获得笔记本电脑");
//		           break;  
//		   case 3:
//			       System.out.println("获得u盘");
//		           
//		   default:
//			       System.out.println("很遗憾，你没用获奖");
//		}
//		System.out.println("--------------");
		
		
	    //String r="第3名";//r的值只能是“第一名”“第二名”“第三名”或其他		
		String r=input.next();
		switch(r){
		   case "第一名"://用r=1表示第一名
		           System.out.println("可以参加夏令营");
		           break;		           
		   case "第二名":
			   	   System.out.println("获得笔记本电脑");
		           break;  
		   case "第三名":
			       System.out.println("获得u盘");
		           break;
		   default:
			       System.out.println("很遗憾，你没用获奖");
		}
		
		input.close();
	}

}

循环语句中变量的使用范围

public class ForDemo1 {

	public static void main(String[] args) {
		
		for(int i=100;i>=1;i--){
		    System.out.println(i);
		}
		//System.out.println(i);//变量i在for语句中定义，只在for语句中有效，只能在for语句中使用
	}

}

循环嵌套

程序1：输出5行星号，每行显示50个星号

public class WhileWhileDemo {
	public static void main(String[] args) {
//		for(int i=1;i<=5;i++) {
//			System.out.println("*******");
//		}
//		//该循环用来输出100个星号
//		for(int i=1;i<=100;i++) {
//			System.out.print("*");
//		}
//		System.out.println();//System.out.print("\n");//表示输出上面的星号后换行
		
		
		for(int i=1;i<=5;i++){//外循环
			//该循环用来输出50个星号
			for(int j=1;j<=50;j++) {//内循环
				System.out.print("*");
			}
			System.out.println();//System.out.print("\n");//表示输出上面的星号后换行
		}		
	}
}

程序2：输出3行星号，第一行显示1个星号，第二行显示3个星号，第三行显示5个星号。

public class WhileWhileDemo {
	public static void main(String[] args) {
		//第1行输出1个星号
		//第2行输出2个星号
		//第3行输出3个星号
		//外循环是用来控制输出几行星号，内循环用来控制输出每行几个星号
		for(int n=1;n<=3;n++){//外循环
			//该循环用来输出n个星号
			for(int i=1;i<=2*n-1;i++) {//内循环
				System.out.print("*");
			}
			System.out.println();//System.out.print("\n");//表示输出上面的星号后换行
		}	
	}
}

程序3：输出一个金字塔型的星号

public class WhileWhileDemo {
	public static void main(String[] args) {	
		int rowCount=3;//定义rowCount表示要输出的行数，rowCount也可以用其它变量名代替
		//外循环是用来控制输出几行星号，内循环用来控制输出每行几个星号
		for(int n=1;n<=rowCount;n++){//外循环
			//该循环用来输出n个空格
			for(int i=1;i<=rowCount-n;i++) {//内循环
				System.out.print(" ");
			}
			//该循环用来输出n个星号
			for(int i=1;i<=2*n-1;i++) {//内循环
				System.out.print("*");
			}
			System.out.println();//System.out.print("\n");//表示输出上面的星号后换行
		}	
	}
}

break语句

public class BreakDemo {
	public static void main(String[] args) {
		//外循环的作用只是用来控制外循环体执行4次
		for(int j=1;j<5;j++) {
			//该循环体的作用是输出“0 1 2 3 4 5 ”
			for(int i=0;i<10;i++) {
				System.out.print(i+"  ");
				if(i==5)
					break;//结束本层循环，如果有外循环的还要执行外循环
			}
		}
	}
}

判断number是不是质数

public class ZhishuDemo {

	public static void main(String[] args) {		
	     //number除以2到number-1之间的数，如果能整除说明number不是质数
		
//		int number=9;
//		if(number%2==0) {
//			System.out.println(number+"不是质数");
//		}
//		if(number%3==0){
//			System.out.println(number+"不是质数");
//		}
//		//当number=9时，number%3==0,这时已经判断出9不是质数，这时不需要再执行下面的判断
//		if(number%4==0){
//			System.out.println(number+"不是质数");
//		}
//		if(number%number-1==0) {
//			System.out.println(number+"不是质数");
//		}
		
		int number=17;
		int i;
		for(i=2;i<=number-1;i++) {
			if(number%i==0) {
				System.out.println(number+"不是质数");
				break;//当判断出number不是质数时不需要再执行后面的判断				
			}			
		}
		//如果number不是质数，程序是通过break结束循环，这意味着i<=number-1
		//如果number是质数，上面的循环语句是通过循环条件i<=number-1结束循环，这时i是不满足i<=number
	    if(i>number-1) {
	    	System.out.println(number+"是质数");
	    }

	}

}

死循环

while(true){

}
for(int i=1;true;i++){
}
以上两个代码都是死循环，使用死循环要注意，在循环体中要有退出循环的语句，例如System.exit(0);或break;

public class SumDemo {

	public static void main(String[] args) {
		// 编写一程序求1+2+3+……+n的值刚好大于6000时n的值是什么。
//		int sum=0;
//		for(int i=1;i<=6000;i++) {
//			sum=sum+i;
//			if(sum>6000) {
//				System.out.println(i);
//				break;
//			}
//		}
		
//		int sum=0;
//		int i=1;
//		while(sum<=6000) {
//			sum=sum+i;//sum=1+2+3+...+n  sum>6000
//			i++;
//		}
//		System.out.println(i-1);
		
		int sum=0;
		int i=1;
		while(true) {//死循环，使用死循环要注意，在循环体中要有退出循环的语句，例如System.exit(0);或break;
			sum=sum+i;//sum=1+2+3+...+n  sum>6000
			if(sum>6000) {
				System.out.println(i);
				break;
			}
			i++;
		}		
	}
}

Continue语句的使用

public class BreakDemo {
	public static void main(String[] args) {
		//外循环的作用只是用来控制外循环体执行4次
		for(int j=1;j<5;j++) {
			//该循环体的作用是输出“0 1 2 3 4 6 7 8 9 ”
//			int i;
//			for(i=0;i<10;i++) {				
//				if(i==5)
//					continue;//continue不执行本次循环continue后面的语句，但还要进入下一趟循环
//				System.out.print(i+"  ");	
//			}
			int i=-1;
			while(i<9) {
				i++;				
				if(i==5)
					continue;//continue不执行本次循环continue后面的语句，但还要进入下一趟循环
				System.out.print(i+"  ");	
				
			}
			System.out.println();
		}		
	}
}

数组的定义

数组的使用

import java.util.Scanner;

public class ArrayDemo {

	public static void main(String[] args) {
	/*  
	    //第一种对数组元素赋值的方法
		double[] s=new double[] {90,80,70,60,50};//这样表示数组s有五个元素，分别是s[0] s[1] s[2] s[3] s[4]
	    //第二种赋值方法
		double[] s=new double[5];
		s[0]=90;
		s[1]=80;
		s[2]=70;
		s[3]=60;
		s[4]=50;
		*/
		//第三种赋值方法
		Scanner input=new Scanner(System.in);
		double[] s=new double[5];
//		s[0]=input.nextDouble();
//		s[1]=input.nextDouble();
//		s[2]=input.nextDouble();
//		s[3]=input.nextDouble();
//		s[4]=input.nextDouble();
		for(int i=0;i<=4;i++) {
			s[i]=input.nextDouble();
		}
		input.close();
		for(int i=0;i<=4;i++) {
			System.out.println(s[i]);
		}
	}

}

遍历数组元素的方法

import java.util.Scanner;

public class ArrayDemo {

	public static void main(String[] args) {
  	   
		double[] s=new double[] {90,80,70,60,50};//这样表示数组s有五个元素，分别是s[0] s[1] s[2] s[3] s[4]
        //第一种输出数组元素的方法
		for(int i=0;i<=4;i++) {
			System.out.println(s[i]);
		}
		//第二种输出数组元素的方法
		for(double a:s) {//s是一个数组名，a是表示数组元素的一个普通变量，double是由数组s的数据类型决定
			//for是循环语句，循环次数由数组s的元素个数决定，该例中s有5个元素，所以该循环执行5次，每一次的a代表的是数组的各个元素
			System.out.println(a);
		}
	}

}

数组求和求平均值

public class ArrayDemo2 {
	public static void main(String[] args) {
		double[] scores= {90,80,70,60,50};
		//求数组元素的和
		double sum=0;
		for(int i=0;i<=4;i++) {
			sum=sum+scores[i];
		}
		System.out.println("数组元素的和为"+sum);
		//求平均值
		double average=sum/5;
		System.out.println("数组元素的平均值为"+average);
	}
}

求一维数组的最大值和最小值

public class ArrayDemo2 {
	public static void main(String[] args) {
		int[] a= {20,80,70,10,90,30,40};
		int max=a[0];//假定第一个元素是最大值,存放当前扫描过的数组元素的最大值
		int min=a[0];//假定第一个元素是最小值
		int x=0;//x表示最大值的下标
		int y=0;//y表示最小值的下标
		
		for(int i=1;i<a.length;i++) {
			//当前元素a[i]比原来假定的最大元素max还大，说明当前的最大元素是a[i],要将a[i]存放在最大元素max中，并将下标存放在最大元素下标x中
			if(a[i]>max) {
				max=a[i];x=i;
			}
			//当前元素a[i]比原来假定的最小元素min还小，说明当前的最小元素是a[i],要将a[i]存放在最小元素min中，并将下标存放在最小元素下标y中
			if(a[i]<min) {
				min=a[i];y=i;
			}
		}
		System.out.println("当前数组的最大元素是"+max+",最大元素的下标为"+x);
		System.out.println("当前数组的最小元素是"+min+",最小元素的下标为"+y);
	}
}

查找数组元素

在数值类型的数组中查找元素：

public class ArraySearch {
	public static void main(String[] args) {
		//判断a[0]==64,如果是则返回数组的下标0，如果不是继续判断下一个元素
		//判断a[1]==64,如果是则返回数组的下标1，如果不是继续判断下一个元素
		//判断a[2]==64,如果是则返回数组的下标2，如果不是继续判断下一个元素
		//..
		//判断a[9]==64,如果是则返回数组的下标9，如果不是继续判断下一个元素
		//如果都找不到，要显示查找失败
		int[] a=new int[] {12,43,74,8,23,62,67,72,10};
		int key=64;//key表示要查找的元素
		int index=-1;//index表示查找到的元素在数组中的下标，用值-1表示还没找到元素
		for(int i=0;i<a.length;i++){
			if(a[i]==key) {
				index=i;
				break;//不用往后查找
			}
		}
		if(index!=-1)
			System.out.println("要查找的元素在数组下标为"+index+"位置上");
		else
			System.out.println("要查找的元素在数组中不存在");
	}

}

在字符串类型的数组中查找元素：

import java.util.Scanner;
public class ArraySearch {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		String[] a=new String[] {"aaa","bbb","ccc","ddd"};
		String key=input.next();//key表示要查找的元素
		int index=-1;//index表示查找到的元素在数组中的下标，用值-1表示还没找到元素
		for(int i=0;i<a.length;i++){
			if(a[i].equals(key)) {
				index=i;
				break;//不用往后查找
			}
		}
		if(index!=-1)
			System.out.println("要查找的元素在数组下标为"+index+"位置上");
		else
			System.out.println("要查找的元素在数组中不存在");
		input.close();
	}
}

在数值类型的数组中查找元素：

public class ArrayDemo {
	public static void main(String[] args) {
		int[] a= {23,56,26,63,97,24,28,76,20,74};
		int key=74;//key表示要查找的元素
		int i;
		for(i=0;i<a.length;i++) {
			if(a[i]==key) {				
				break;
			}
		}
		//在含有break语句的循环里面，退出循环有两种方式，一种是不满足循环条件时退出，即i>=10时退出，一种时遇到break语句时退出，这时i<=9
		if(i>=a.length)
			System.out.println("该元素在数组中不存在");
		else
			System.out.println("找到key,key的下标为"+i);
		
	}
}

在字符串类型的数组中查找元素：

public class ArrayDemo {
	public static void main(String[] args) {
		String[] a= {"Tom","Mike","Mary","Sasa"};
		String key="Mary";//key表示要查找的元素
		int i;
		for(i=0;i<a.length;i++) {
			if(a[i].equals(key)) {				
				break;
			}
		}
		//在含有break语句的循环里面，退出循环有两种方式，一种是不满足循环条件时退出，即i>=10时退出，一种时遇到break语句时退出，这时i<=9
		if(i>=a.length)
			System.out.println("该元素在数组中不存在");
		else
			System.out.println("找到key,key的下标为"+i);
		
	}
}

删除数组元素

public class ArrayDemo4 {
	public static void main(String[] args) {
		int[] a=new int[] {1,2,3,4,5,6,7,8,9};
		int k=3;//k表示要删除的元素下标
		for(int i=k+1;i<=a.length-1;i++)
			a[i-1]=a[i];
		//删除数组元素后数组的长度a.length是没有变化的
		for(int i=0;i<a.length-1;i++) {
			System.out.print(a[i]+" ");
		}
	}
}

在数组中插入元素

public class DemoClass {
public static void main(String[] args) {
//数组最后一个元素0在此处不代表元素值，只是预留一个元素的空间用来插入元素，即把当前数组看成只存放9个元素
int[] a=new int[]{5,13,19,21,37,56,64,75,80,0};
int k=6;//在下标为6的位置插入元素
int key=60;//输入的元素值为60
for(int i=8;i>=k;i--){
	a[i+1]=a[i];
}
a[k]=key;
for(int i=0;i<10;i++)
	System.out.print(a[i]+"  ");
	}
}


public class InsertDemo {
	public static void main(String[] args) {
		//在进行插入时，一定要保证插入后的数组长度不大于原来定义的数组长度
		int[] a=new int[10];//在new int[]的时候已经为数组分配存储空间，在这里已经确定了数组的长度
		a[0]=1;a[1]=2;a[2]=3;a[3]=4;a[4]=5;a[5]=6;a[6]=7;a[7]=8;
		int k=4;//k表示要插入的元素在数组中的下标
		int key=50;//key表示要插入的元素，要插入的元素的类型必须与数组的类型一致
		for(int i=7;i>=k;i--){
			a[i+1]=a[i];
		}
		a[k]=key;
		for(int i=0;i<=8;i++){
			System.out.print(a[i]+" ");
		}
	}
}

数组排序

package project1;

public class SortArray {

	public static void main(String[] args) {
		int[] a=new int[]{49,38,65,97,76,13,27};
//		//第一趟扫描，目的是找出数组最小的元素，放在数组下标为0的位置
//		int k=0;//k存放当前数组最小的元素的下标，一开始假设第一个元素最小，所以k=0
//		//通过下面的循环可以找出数组中的最小元素的下标k
//		for(int j=1;j<=6;j++){
//			if(a[k]>a[j]){// 当发现数组后面的某一个元素a[i]比我们原来假定的最小元素a[k]小
//				k=j;//将当前最小元素的下标 j存放在 k中，使k始终保存当前扫描过的元素的最小值的下标
//			}
//		}
//		int t;
//		t=a[k];a[k]=a[0];a[0]=t;//实现a[k]和a[0]的交换
//		
//		//第二趟扫描，目的是找出数组第二小的元素，放在数组下标为1的位置，也就是数组的第一个元素不用考虑了
//		k=1;//k存放当前数组（从第二个元素开始的数组）最小的元素的下标，一开始假设第一个元素最小，所以k=1
//		//通过下面的循环可以找出数组中的最小元素的下标k
//		for(int j=2;j<=6;j++){
//			if(a[k]>a[j]){// 当发现数组后面的某一个元素a[i]比我们原来假定的最小元素a[k]小
//				k=j;//将当前最小元素的下标 j存放在 k中，使k始终保存当前扫描过的元素的最小值的下标
//			}
//		}	
//		t=a[k];a[k]=a[1];a[1]=t;//实现a[k]和a[1]的交换
//		
//		//第三趟扫描，目的是找出数组第三小的元素，放在数组下标为2的位置，也就是数组的前两个元素不用考虑了
//		k=2;//k存放当前数组（从第三个元素开始的数组）最小的元素的下标，一开始假设第一个元素最小，所以k=2
//		//通过下面的循环可以找出数组中的最小元素的下标k
//		for(int j=3;j<=6;j++){
//			if(a[k]>a[j]){// 当发现数组后面的某一个元素a[i]比我们原来假定的最小元素a[k]小
//				k=j;//将当前最小元素的下标 j存放在 k中，使k始终保存当前扫描过的元素的最小值的下标
//			}
//		}	
//		t=a[k];a[k]=a[2];a[2]=t;//实现a[k]和a[2]的交换
//		
//		//......
//		
//		//第六趟扫描，目的是找出数组第六小的元素，放在数组下标为5的位置，也就是数组的前五个元素不用考虑了
//		k=5;//k存放当前数组（从第五个元素开始的数组）最小的元素的下标，一开始假设第一个元素最小，所以k=5
//		//通过下面的循环可以找出数组中的最小元素的下标k
//		for(int j=6;j<=6;j++){
//			if(a[k]>a[j]){// 当发现数组后面的某一个元素a[i]比我们原来假定的最小元素a[k]小
//				k=j;//将当前最小元素的下标 j存放在 k中，使k始终保存当前扫描过的元素的最小值的下标
//			}
//		}	
//		t=a[k];a[k]=a[5];a[5]=t;//实现a[k]和a[5]的交换
		
		for(int i=1;i<=6;i++){//i表示第几趟扫描
			//第i趟扫描，目的是找出数组最小的元素，放在数组下标为i-1的位置
			int k=i-1;//k存放当前数组最小的元素的下标，一开始假设第一个元素最小，所以k=0
			//通过下面的循环可以找出数组中的最小元素的下标k
			for(int j=i;j<=6;j++){
				if(a[k]>a[j]){// 当发现数组后面的某一个元素a[i]比我们原来假定的最小元素a[k]小
					k=j;//将当前最小元素的下标 j存放在 k中，使k始终保存当前扫描过的元素的最小值的下标
				}
			}
			int t;
			t=a[k];a[k]=a[i-1];a[i-1]=t;//实现a[k]和a[i-1]的交换
		}
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
	}

}





public class Demo {
	public static void main(String[] args) {
		int[] a=new int[]{49,38,65,97,76,13,27,56,23,64,57};
		for(int i=1;i<=a.length-1;i++){
			int k=i-1;//k为当前假定的最小的元素的下标,a[k]则表示当前假定的最小元素
			//下面的循环用来找出数组下标为k~a.length-1（数组的最后一个元素）之间的元素的最小值，最小值存放在下标为k的元素中
			for(int j=k+1;j<=a.length-1;j++){
				if(a[k]>a[j])//当前元素a[j]比原来假定的最小元素a[k]小
					k=j;//当前下标为j的元素是最小元素，将j存放在k中，则k为当前最小元素的下标
			}
			//拿数组a[i-1]与当前的最小元素a[k]进行交换，把最小元素放在a[i-1]中
			int t=a[i-1];a[i-1]=a[k];a[k]=t;
		}
		for(int i=0;i<=a.length-1;i++){
			System.out.print(a[i]+" ");
		}
		
//		int k=1;//k为当前假定的最小的元素的下标,a[k]则表示当前假定的最小元素
//		//下面的循环用来找出数组下标为k~a.length-1（数组的最后一个元素）之间的元素的最小值，最小值存放在下标为k的元素中
//		for(int j=k+1;j<=a.length-1;j++){
//			if(a[k]>a[j])//当前元素a[j]比原来假定的最小元素a[k]小
//				k=j;//当前下标为j的元素是最小元素，将j存放在k中，则k为当前最小元素的下标
//		}
//		//拿数组a[1]与当前的最小元素a[k]进行交换，把最小元素放在a[1]中
//		int t=a[1];a[1]=a[k];a[k]=t;
//		
//		int k=2;//k为当前假定的最小的元素的下标,a[k]则表示当前假定的最小元素
//		//下面的循环用来找出数组下标为k~a.length-1（数组的最后一个元素）之间的元素的最小值，最小值存放在下标为k的元素中
//		for(int j=k+1;j<=a.length-1;j++){
//			if(a[k]>a[j])//当前元素a[j]比原来假定的最小元素a[k]小
//				k=j;//当前下标为j的元素是最小元素，将j存放在k中，则k为当前最小元素的下标
//		}
//		//拿数组a[2]与当前的最小元素a[k]进行交换，把最小元素放在a[2]中
//		int t=a[2];a[2]=a[k];a[k]=t;
	}
}

Arrays数组的相关方法

import java.util.Arrays;
public class ArraysDemo {

	public static void main(String[] args) {
		int[] a=new int[]{12,45,26,75,34};
//		for(int i=0;i<a.length;i++){
//			System.out.print(a[i]+" ");
//		}
//		System.out.println();
		String s=Arrays.toString(a);//把数组的内容转换成字符串类型
		System.out.println(s);//输出数组
		//上面两个语句可写成下面一个语句
		System.out.println(Arrays.toString(a));
		
		int[] b=new int[10];
		System.out.println(Arrays.toString(b));
		Arrays.fill(b,3);//Arrays.fill（ 数组名,要赋的值）	
		System.out.println(Arrays.toString(b));
		Arrays.fill(b,4,8,6);//Arrays.fill（ 数组名, 赋值的开始下标，赋值的结束下标+1，要赋的值）
		System.out.println(Arrays.toString(b));
		
		String[] c=new String[10];
		System.out.println(Arrays.toString(c));
		Arrays.fill(c, "hello");
		System.out.println(Arrays.toString(c));
		Arrays.fill(c,1,5,"world");
		System.out.println(Arrays.toString(c));
		
		String[] d=new String[]{"aa","bb","cc","dd","ee","ff","gg"};
		String[] e;
		e=Arrays.copyOf(d, 4);//Arrays.copyOf(要拷贝的数组名，要拷贝的元素个数）
		System.out.println(Arrays.toString(e));
		e=Arrays.copyOfRange(d, 2, 6);//Arrays.copyOfRange(要拷贝的数组名，拷贝的起点下标，拷贝的终点下标+1）
		System.out.println(Arrays.toString(e));
		
		String[] f1=new String[]{"aa","bb","cc","dd","ee","ff","gg"};
		String[] f2=new String[]{"aa","bb","cc","dd","ee","ff","gg"};
		boolean f=Arrays.equals(f1, f2);//如果f1与f2相等， 那么f=true,否则 f=false
		if(f){		
		System.out.println("这两个数组相等");
		}
		if(!f){			
			System.out.println("这两个数组不相等");
		}
		//上面两个if语句等价于下面这语句
		if(f){		
			System.out.println("这两个数组相等");
		}else{			
			System.out.println("这两个数组不相等");
		}
			
		int[] g=new int[]{12,45,26,75,34};
		Arrays.sort(g);	//对数组g进行排序，并把排序后的结果存在数组g中
		System.out.println(Arrays.toString(g));
		int[] h=new int[]{12,32,97,43,45,26,75,34};
		Arrays.sort(h,0,6);//对数组b下标为0~6-1之间的元素进行升序排序
		System.out.println(Arrays.toString(h));
		
		int[] k=new int[]{12, 26, 32, 43, 45, 75, 97};//要查找的数组必须是有序的。
		System.out.println(Arrays.toString(k));
		int i=Arrays.binarySearch(k, 97);//查找97在数组中的位置，将找到的位置（数组的下标）存放在i中,如果找不到，则i的值为负数
		if(i>=0){
			System.out.println("97在数组的下标为"+i);
		}else{
			System.out.println("查找失败");
		}
	}
}

二维数组

public class ArrayDemo {
	public static void main(String[] args) {
		int[][] a=new int[][]{{1,2,3},{4,5,6}};
		//a[0][0] a[0][1] a[0][2]
		//a[1][0] a[1][1] a[1][2]
		System.out.println(a[0][0]+" "+a[0][1]+" "+a[0][2]);
		System.out.println(a[1][0]+" "+a[1][1]+" "+a[1][2]);
		System.out.println("-------------------");
		
		int[][] b=new int[][]{{1,2},{4,5,6}};
		//a[0][0] a[0][1] a[0][2]
		//a[1][0] a[1][1] a[1][2]
		System.out.println(b[0][0]+" "+b[0][1]);//不能输出a[0][2],因为第一行只有两个元素
		System.out.println(b[1][0]+" "+b[1][1]+" "+b[1][2]);
		System.out.println("-------------------");
		
		for(int i=0;i<2;i++){//2是二维数组a的行数
			System.out.println(a[i][0]+" "+a[i][1]+" "+a[i][2]);
		}
		System.out.println("-------------------");
		
		for(int i=0;i<2;i++){//2是二维数组a的行数
			//System.out.println(a[i][0]+" "+a[i][1]+" "+a[i][2]);
//			System.out.print(a[i][0]+" ");
//			System.out.print(a[i][1]+" ");
//			System.out.print(a[i][2]+" ");
			for(int j=0;j<3;j++){//3是二维数组a的列数
				System.out.print(a[i][j]+" ");				
			}
			System.out.println();
		}
		System.out.println("-------------------");
		
		String[][] d=new String[][]{{"aa","bb"},{"cc","dd"},{"ee","ff"}};
		for(int i=0;i<3;i++){//3是二维数组a的行数
			for(int j=0;j<2;j++){//2是二维数组a的列数
				System.out.print(d[i][j]+" ");				
			}
			System.out.println();
		}
		System.out.println("-------------------");

//当数组的列数不一致时可采用下面的方式进行输出
		String[][] f=new String[][]{{"aa","bb","gg","rr"},{"cc","dd"},{"ee","ff"}};
		for(int i=0;i<3;i++){//3是二维数组a的行数
			for(int j=0;j<f[i].length;j++){//f[i]是第i+1行的数组名，数组名.length表示数组的元素个数，即f[i].length表示第i+1行的元素个数
				System.out.print(f[i][j]+" ");				
			}
			System.out.println();
		}
		System.out.println("-------------------");
	}

}

二维数组求和

public class ArrayDemo {

	public static void main(String[] args) {
		int[][] a=new int[][]{{1,2,3},{4,5,6}};
//		//下面的代码是求所有元素之和
//		int sum=0;
//		for(int i=0;i<2;i++){
//			for(int j=0;j<3;j++){				
//				sum=sum+a[i][j];
//			}
//		}
//		System.out.println(sum);//求二维数组所有元素之和
		
//		//用下面几个语句可以求第一行三个元素的和
//		int sum=0;
//		sum=sum+a[0][0];
//		sum=sum+a[0][1];
//		sum=sum+a[0][2];
//		System.out.println(sum);
		
//		//将上面的代码改为用循环实现的方法
//		int sum=0;
//		for(int j=0;j<3;j++){
//			sum=sum+a[0][j];
//		}
//		System.out.println(sum);
		
//		//用下面几个语句可以求第二行三个元素的和	
//		int sum=0;
//		sum=sum+a[1][0];
//		sum=sum+a[1][1];
//		sum=sum+a[1][2];
//		System.out.println(sum);
		
//		//将上面的代码改为用循环实现的方法
//		int sum=0;
//		for(int j=0;j<3;j++){
//			sum=sum+a[1][j];
//		}
//		System.out.println(sum);
		
		//求各行元素之和的代码
		for(int i=0;i<2;i++){
			int sum=0;
			for(int j=0;j<3;j++){
				sum=sum+a[i][j];
			}
			System.out.println(sum);
		}
	}
}

无参数无返回值的方法

public class fun {
	//方法的定义————————————
	//无参数无返回值的方法,方法名为showMessage, 方法的功能是输出一行*
	static void showMessage(){//{}中的内容叫方法体，表示调用这个方法后要做的操作。该方法不会单独运行，只有在main()出现调用语句才执行
		System.out.println("*****************");
	}
	//以上内容都属于方法的定义——————————
	
	public static void main(String[] args) {
		System.out.println("————————————————————");		
		showMessage();//调用方法的语句，也叫调用语句，当执行到该语句的时候，会跳转到方法定义的地方开始执行，当整个方法执行结束会回到该位置继续执行该语句后面的代码
		System.out.println("===================");
	}
}

带参数的方法

//案例1：
public class FunDemo {

	//方法的定义
	public static void add(){
		int a=1,b=2;
		int c=a+b;
		System.out.println(c);
	}

	//方法的定义
	public static void add11(int a,int b){//方法定义中的参数a和b叫形参，形参前面必须写数据类型		
		int c=a+b;//a和b来自于主方法main()的a和b,这时需要将a和b定义成参数
		System.out.println(c);
	}
	
	public static void main(String[] args) {
		add();//调用方法的语句，简称调用语句，语法：方法名（）；当遇到调用语句时，程序会跳到方法定义的地方开始执行
		//当整个方法体执行结束后，程序会回到调用语句的地方，执行调用语句后面的代码。
		
		int a=1,b=2;
		add11(a,b);//调用语句中的参数a和b叫实参，在调用语句中实参前面不能写类型名称int,而且要求a和b是已经赋值的变量
		//当执行带参数的方法调用时，跳到方法定义的位置，先将实参赋值给形参，再执行方法体的内容
		int x=2,y=4;
		add11(x,y);//实参和形参的变量名可以不一致，但类型必须一样
		
		add11(2,4);//实参可以用具体的值表示
	}
}

//案例2：
public class MethodDemo {
	public static void add(int a,int b){//方法定义中的参数叫形参
//		int a=1,b=2;
		int c=a+b;//这里的a和b要和形参的名称一致
		System.out.println(c);
	}
	public static void main(String[] args) {
		int x=1,y=2;
		add(x,y);//调用语句中的参数叫实参，实参的名称可以和形参的名称不一致，但是类型必须一致。当执行带有参数的方法调用语句的时候，程序跳到方法定义的地方开始执行，并且把实参赋值给形参。
		add(3,4);//实参可以用值表示

	}
}

//案例3：
import java.util.Scanner;

public class MethodDemo {
	static void fun(String r){//将r定义在参数中，表示r是从主方法获取，不是在fun（）方法输入
//		Scanner input=new Scanner(System.in);
//		String r=input.next();
		switch(r){
		   case "第一名"://用r=1表示第一名
		           System.out.println("可以参加夏令营");
		           break;		           
		   case "第二名":
			   	   System.out.println("获得笔记本电脑");
		           break;  
		   case "第三名":
			       System.out.println("获得u盘");
		           break;
		   default:
			       System.out.println("很遗憾，你没用获奖");
		}
//		input.close();
		
	}
	public static void main(String[] args) {
		//1.第一种调用方式，直接将值作为实参
		fun("第一名");//方法调用语句，执行该方法的时候会跳到方法定义的地方开始执行，并将"第一名"赋值给方法的形参r,等fun方法执行完毕会回到该语句的位置，继续执行后面的语句
		//2.第二种调用方式，用已赋值的变量作为实参
		Scanner input=new Scanner(System.in);
		String r=input.next();
		fun(r);
		r=input.next();
		fun(r);
		r=input.next();
		fun(r);
		input.close();
	}
}

//案例4：
public class SwitchDemo2 {

	public static void fun(int r) {
		switch(r) {
		case 1:
			System.out.println("可以参加夏令营");
			break;
		case 2:
			System.out.println("获得笔记本电脑");
			break;
		case 3:
			System.out.println("获得移动硬盘");
			break;
		default:
			System.out.println("没有获得奖励");
		}			
	}
	
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int r=input.nextInt();
//		switch(r) {
//			case 1:
//				System.out.println("可以参加夏令营");
//				break;
//			case 2:
//				System.out.println("获得笔记本电脑");
//				break;
//			case 3:
//				System.out.println("获得移动硬盘");
//				break;
//			default:
//				System.out.println("没有获得奖励");
//		}		
		fun(r);
		input.close();
	}

}


//案例5：
public class ForDemo {	
	public static void main(String[] args) {
		fun();

		int n=5;
		fun11(n);
		fun11(5);
	}

	public static void fun() {
		double sum=0;
		int n=50;
		for(int i=1;i<=n;i++) {
			sum=sum+i;
		}
		System.out.println(sum);
	}	
	
	public static void fun11(int n) {
		double sum=0;
//		int n=50;
		for(int i=1;i<=n;i++) {
			sum=sum+i;
		}
		System.out.println(sum);
	}
}

//案例6：
public class MethodDemo {
	static void output(String[] s){
		for(int i=0;i<s.length;i++) {
			System.out.println(s[i]);
		}
	}
	public static void main(String[] args) {
		double[] s=new double[] {90,80,70,60,50,40};
		String[] a={"aaaa","bbb","cc"};
		output(a);
	}
}

有返回语句的方法

什么情况下需要定义方法的返回值？

当执行这个方法要得到一个值时就需要写返回语句。

返回语句注意事项：

l 如果方法具有返回值，方法中必须使用关键字return返回该值，返回值的类型决定了方法的类型。如果方法没有返回值，方法类型为void。

l 返回值只能有一个

案例1

public class FunDemo1 {

	public static int add(int a,int b){//方法定义中的参数叫形参 ，当方法有return语句时，return后面变量的类型就决定方法的类型，如果没有return语句，方法的类型就用void
//		int a=1,b=2;
		int c=a+b;//这里的a和b要和形参的名称一致
		return c;//当执行这个方法要得到一个值的时候，就通过return返回得到的值
	}

	public static void main(String[] args) {
		int x=1,y=2;
		int d=add(x,y);//调用语句中的参数叫实参，实参的名称可以和形参的名称不一致，但是类型必须一致。当执行带有参数的方法调用语句的时候，程序跳到方法定义的地方开始执行，并且把实参赋值给形参。 
		//当方法有返回语句时，调用语句通常要赋值一个变量，该变量的类型与返回语句后面的变量类型一致
		System.out.println(d);
		System.out.println(add(3,4));//实参可以用值表示	
	}
}

案例2

public class FunDemo2 {
	static int getSum(){
		int sum=0;
		for(int i=1;i<=100;i++){
			sum=sum+i;
		}
		return sum;
	}
	static int getSum(int n){
		int sum=0;
		for(int i=1;i<=n;i++){
			sum=sum+i;
		}
		return sum;
	}
	public static void main(String[] args) {
//		int sum=0;
//		for(int i=1;i<=100;i++){
//			sum=sum+i;
//		}
		int sum1=getSum();		
		System.out.println(sum1);
		int sum2=getSum(10);
		System.out.println(sum2);
	}
}

案例3

public class FunDemo3 {
	static void getArea1(){
		int a=4;
		int area=a*a;
		System.out.println(area);
	}
	static int getArea2(int a){
		int area=a*a;
		return area;
	}
	public static void main(String[] args) {
		getArea1();
		int length=2;
		int area=getArea2(length);
		System.out.println(area);
	}
}

案例4

import java.util.Scanner;
public class FunDemo4 {
	static String fun(String r){//将r定义在参数中，表示r是从主方法获取，不是在fun（）方法输入
		switch(r){
		   case "第一名"://用r=1表示第一名
		           return "可以参加夏令营";	
		   case "第二名":
			   	   return "获得笔记本电脑";		           
		   case "第三名":
			       return "获得u盘";		           
		   default:
			       return "很遗憾，你没用获奖";
		}	
	}
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		String r=input.next();
		input.close();
		
		System.out.println(fun(r));
		
		String s=fun(r);
		System.out.println(s);	
	}
}

System.out.printf()语句的使用

public class FunClass1 {
	public static void main(String[ ] args){
     /*
		int a=10;
		System.out.printf("a=%d\n", a);//输出整数类型变量的值用%d
		double b=10;
		System.out.printf("b=%f\n", b);//输出double类型变量或float类型变量的值用%f
		String c="Hello";
		System.out.printf("c=%s\n", c);//输出字符串变量的值用%s
		char d='A';
		System.out.printf("d=%c\n", d);//输出字符变量的值用%c
		*/

		int a=10;
		System.out.printf("a=%4d\n", a);//%4d表示输出占用4位
		System.out.printf("a=%d\n", a);
		double b=10.5;
		System.out.printf("b=%f\n", b);
		System.out.printf("b=%8.2f\n", b);//%8.2表示输出的内容包括整数部分、小数点和小数部分共占用8位，小数部分占用2位
		String c="Hello";
		System.out.printf("c=%s\n", c);
		System.out.printf("c=%10s\n", c);
		System.out.printf("c=%S\n", c);
		char d='A';
		System.out.printf("d=%c\n", d);
	}
}

类类型的定义和使用

案例1
class Student{//Student是一种类类型，
	long number;
	String name;
	String sex;
	String className;
}
public class FunClass1 {

	public static void main(String[ ] args){
		//定义变量的格式：类型名称 变量名；
		//值类型变量定义后直接通过=进行赋值
		//引用类型变量定义后要先开辟存储空间，再进行赋值
		//数组和类都是引用类型，所以定义变量后都要通过new开辟存储空间，再赋值
		int i=1;
		int[] a=new int[9];
		Student obj=new Student();//用类类型定义的变量一般叫对象，obj不叫变量，应该称“对象”
		obj.number=19012123;
		obj.name="张三";
		obj.sex="男";
		obj.className="计应1班";
	}
}

案例2：
class NumberClass{//NumberClass是类类型名
	int num;//num是成员名，全称叫“属性成员”
}
public class FunDemo2 {

	public static void main(String[] args) {
		//定义类对象的语法格式：  类类型名称   对象名=new 类类型名称（）；
		NumberClass obj=new NumberClass();
		//访问成员的格式:   对象名.成员名=值;
		obj.num=10;
		System.out.println(obj.num);
	}

}

参数的传递方式

当基本数据类型（如int、float、double）作为参数时，参数的传递方式是值传递，是单向传递，在方法体中改变形参的值不会更改到主调方法中实参的值。

当引用类型（如类类型、数组类型）作为参数时，参数的传递方式是引用传递，是双向传递，在方法体中改变形参的值可以改变主调方法中实参的值。

class Student {//Student是一种数据类型，是类类型
	String name;
	String number;
	String className;
	double score;	
}

public class MainClass {
	static void input(Student s){//参数是引用类型，实现的是引用传递，是双向传递，在方法体里面改变形参的内容会改变主方法中实参的内容
//s=new Student();//错误，加上该语句就不能实现双向传递
s.name="张三";
		s.number="001";
		s.className="1班";
		s.score=90;
	}
	static void input2(int i){//参数是普通数据类型，实现的是值传递，是单向传递，在方法体里面改变形参的内容不会改变主方法中实参的内容
		i=i+10;
	}
	public static void main(String[] args) {
		Student s=new Student();
		input(s);
		System.out.println(s.name+" "+s.number+" "+s.className+" "+s.score);
		int i=1;
		input2(i);
		System.out.println(i);
	}

}
运行结果：
张三 001 1班 90.0
1

分析：

值传递：
public class MainClass1 {
	public static void swap(int a,int b){
		int c;
		c=a;a=b;b=c;
		System.out.printf("a=%d,b=%d\n",a,b);
	}
	public static void main(String[ ] args){
		int a=1,b=2;
		swap(a,b);
		System.out.printf("a=%d,b=%d\n",a,b);
	}
}

引用传递：
class NumberClass{
	int number;
}
public class MainClass1 {
	public static void swap(NumberClass a,NumberClass b){
		int c;
		c=a.number;a.number=b.number;b.number=c;
		System.out.printf("a=%d,b=%d\n",a.number,b.number);
	}
	public static void main(String[ ] args){
		NumberClass a=new NumberClass();
		NumberClass b=new NumberClass();
		a.number=1;
		b.number=2;
		swap(a,b);
		System.out.printf("a=%d,b=%d\n",a.number,b.number);
	}
}

案例3：
class NumberClass{
	int num;
}
public class FunDemo2 {
	//该方法不能修改主方法中实参的值
	public static void swap(NumberClass a,NumberClass b) {
		NumberClass c;
		c=a;a=b;b=c;
		System.out.println("swap:"+a.num+" "+b.num);
	}
	//该方法可以修改主方法中实参的值
	public static void swap1(NumberClass a,NumberClass b) {
		int c;
		c=a.num;a.num=b.num;b.num=c;
		System.out.println("swap1:"+a.num+" "+b.num);
	}
	public static void main(String[] args) {
		NumberClass obj1=new NumberClass();	obj1.num=1;
		NumberClass obj2=new NumberClass();	obj2.num=2;
		
		swap(obj1,obj2);		
		System.out.println("main:"+obj1.num+" "+obj2.num);
		
		swap1(obj1,obj2);		
		System.out.println("main:"+obj1.num+" "+obj2.num);
	}
}

数组作为参数是引用传递方式

import java.util.Scanner;

public class MainClass {
	static void input(int[] a){	
//		a=new int[5];//注意，不能在方法体中写该语句，如果写该语句，在方法体中对数组a赋值相当于是对方法体中开辟的空间赋值
		Scanner input=new Scanner(System.in);
		for(int i=0;i<=4;i++){
			a[i]=input.nextInt();
		}
		input.close();
	}
	static void output(int[] a){
		for(int i=0;i<=4;i++){
			System.out.print(a[i]+" ");
		}
		System.out.println();
	}
	static int getMax(int[] a){
//		int[] a= {20,80,70,10,90,30,40};
		int max=a[0];//假定第一个元素是最大值,存放当前扫描过的数组元素的最大值		
		for(int i=1;i<a.length;i++) {
			//当前元素a[i]比原来假定的最大元素max还大，说明当前的最大元素是a[i],要将a[i]存放在最大元素max中，并将下标存放在最大元素下标x中
			if(a[i]>max) {
				max=a[i];
			}
		}
		return max;
	}
	public static void main(String[] args) {
		int[] b=new int[5];
		input(b);
		output(b);

		int max=getMax(b);
		System.out.println("当前数组的最大元素是"+max);
	
	}

}

如何让方法返回多个值

如何让方法返回多个值——借助类变量“返回”多个值，即将要得到的多个值定义成类变量（定义在类的里面，方法的外面）。

案例1：
public class MainClass {
	static int c,d;
	static void fun(int a,int b){//执行该方法要得到多个值，不能通过return语句返回多个值，可以将要返回的值定义成类变量（定义在类里面，方法的外面叫类变量）。
		//类变量可以给类的所有方法共同使用，也就是说在fun修改类变量的值，然后在主方法中输出类变量的值
		c=a+b;
		d=a-b;
	}
	public static void main(String[] args) {
		int x=1,y=2;
		fun(x,y);
		System.out.println("x+y="+c+",x-y="+d);
	}
}

案例2：
import java.util.Scanner;
public class FunDemo3 {
	static int max,min;//类变量，可以给类中的所有方法使用
	static void input(int[] a){	
//		a=new int[5];//注意，不能在方法体中写该语句，如果写该语句，在方法体中对数组a赋值相当于是对方法体中开辟的空间赋值
		Scanner input=new Scanner(System.in);
		for(int i=0;i<=4;i++){
			a[i]=input.nextInt();
		}
		input.close();
	}
	static void output(int[] a){
		for(int i=0;i<=4;i++){
			System.out.print(a[i]+" ");
		}
		System.out.println();
	}
	static void getMaxMin(int[] a){
//		int[] a= {20,80,70,10,90,30,40};
		max=a[0];//假定第一个元素是最大值,存放当前扫描过的数组元素的最大值	
		min=a[0];
		for(int i=1;i<a.length;i++) {
			//当前元素a[i]比原来假定的最大元素max还大，说明当前的最大元素是a[i],要将a[i]存放在最大元素max中，并将下标存放在最大元素下标x中
			if(a[i]>max) {
				max=a[i];
			}
			if(a[i]<min){
				min=a[i];
			}
		}	
	}
	public static void main(String[] args) {
		int[] b=new int[5];
		input(b);
		output(b);

		getMaxMin(b);
		System.out.println("当前数组的最大元素是"+max+"，最小元素是"+min);
	
	}

}

变量的作用域

变量的作用域是指该变量在程序代码中的作用区域，在该区域外不能直接访问变量。

变量在哪一个{}中定义，就能在定义它的{}中使用。

public class FunDemo3 {
	static int a;//类变量，全局变量， 可以给类中的所有方法使用
	static void fun(int c){	//形参c也是局部变量，只能在它定义的方法中使用
		a=90;
		System.out.println(a);
		
		int b=70;//在方法中定义的局部变量，只能在它定义的方法中使用
		System.out.println(b);
		
		c=60;
		System.out.println(c);
	}
	public static void main(String[] args) {
		a=80;
		System.out.println(a);
	
		//System.out.println(b);//错误，没法使用fun()中的b
		//System.out.println(c);//错误，没法使用fun()中的形参c
		
		for(int i=1;i<=5;i++){//i定义在循环语句中，属于循环语句中的局部变量，只能在循环语句中使用
			System.out.println(i);
		}
		//System.out.println(i);//错误，在循环语句的外面不能使用循环语句中定义的变量
		
		{
			int d=10;//d在{}中定义，只能在{}中使用
			System.out.println(d);
		}
		//System.out.println(d);//错误，不能在上述{}外面使用{}中定义的变量		
	}
}

Math类的使用

import java.util.Random;
public class MainClass {
	public static void main(String[] args) {
		double a=Math.sqrt(4);
		System.out.println(a);
		double b=Math.abs(-1);
		System.out.println(b);
		int c=Math.max(90,80);
		System.out.println(c);
	}
}

产生随机数

import java.util.Random;
public class MainClass {
	public static void main(String[] args) {
		//第一种产生随机数的方法
		double d=Math.random();//产生0-1之间的随机数
		System.out.println(d);
		int e=(int)(d*10)+10;
		System.out.println(e);
		//第二种产生随机数的方法
		Random r=new Random();//不加参数，每次运行时产生的随机数都不一样
		for(int i=0;i<20;i++) {
			int g=r.nextInt(10);//产生0-10之间的随机数
			System.out.print(g+"  ");
		}
		System.out.println();
		Random r2=new Random(9);//加了参数后，每次运行时产生的随机数都一样
		for(int i=0;i<20;i++) {
			int g=r2.nextInt(10);//产生0-10之间的随机数
			System.out.print(g+"  ");
		}
		System.out.println();
	}
}

String类的使用

public class MainClass {
	public static void main(String[] args) {
		String s="Hello";
		String s1=new String("Hello");
		System.out.println(s.charAt(1));
		System.out.println(s.compareTo("Hf"));
		System.out.println(s.equals("hello"));
		System.out.println(s.concat(" world"));
		System.out.println(s.contains("he"));
		System.out.println(s.endsWith("lo"));
		System.out.println(s.startsWith("He"));
		System.out.println(s.indexOf("l"));
		System.out.println(s.lastIndexOf("l"));
		System.out.println(s.isEmpty());
		System.out.println(s.length());
		System.out.println(s.matches("[a-z]*@[0-9]{3}.com"));//正则表达式
		System.out.println(s.replace("H","h"));
		System.out.println(s.substring(3));
		System.out.println(s.substring(1,4));	
		System.out.println(s.toLowerCase());
		System.out.println(s.toUpperCase());

		char[] a= {'a','b','c','d','e'};
		String b=String.copyValueOf(a);
		System.out.println(b);
		String c=String.copyValueOf(a,1,3);
		System.out.println(c);
		
		String s2="aa,bb,dd,ffff,gg";
		String[] ss=s2.split(",");
		for(int i=0;i<ss.length;i++) {
			System.out.println(ss[i]);
		}
	}
}

String类型和StringBuffer类型的转换

public class MainClass {
	public static void main(String[] args) {
		String x=new String("java");
		StringBuffer y=new StringBuffer(x);
		System.out.println(y);
		
		StringBuffer h=new StringBuffer("java");
		String g=new String(h);
		System.out.println(g);		
	}
}

String类型和StringBuffer类型的区别

public class MainClass {
	public static void main(String[] args) {
		StringBuffer s=new StringBuffer("Hello");//可变字符串，可对字符串本身进行修改
		s.append(" World");
		System.out.println(s);
		
		String s1=new String("Hello");//不可变字符串，不能对字符串本身进行修改，对字符串进行操作后一般要赋值给另一个变量
		String a=s1.concat(" World");
		System.out.println(s1);
		System.out.println(a);		
	}
}

StringBuffer类型的使用

public class MainClass {
	public static void main(String[] args) {
		StringBuffer s1=new StringBuffer("Hello");//可变字符串，可对字符串本身进行修改
		s1.append(" World");
		System.out.println(s1);
		
		StringBuffer s2=new StringBuffer("Hello");
		s2.deleteCharAt(0);
		System.out.println(s2);
		
		StringBuffer s3=new StringBuffer("Hello");
		s3.replace(2, 4, "aaaa");
		System.out.println(s3);
		
		StringBuffer s4=new StringBuffer("Hello");
		s4.insert(3, "bb");
		System.out.println(s4);
		
		StringBuffer s5=new StringBuffer("Hello");
		s5.reverse();
		System.out.println(s5);
	}
}

类型转换

public class MainClass2 {
	public static void main(String[] args) {
		//基本数据类型和类类型的转换
		//基本数据类型->类类型
		//int->Integer
		int ii=12;
		Integer i=new Integer(ii);
		//double->Double
		double dd=12.5;
		Double d=new Double(dd);
		//类类型->基本数据类型
		//Integer->int
		Integer a=new Integer(12);
		int aa=a.intValue();
		//Double->double
		Double b=new Double(12.5);
		double bb=b.doubleValue();
		
		//基本数据类型和字符串的转换
		//String->int,double
		String s1="12";
		int a1=Integer.parseInt(s1);//Integer.parseInt()将字符串类型转换成int
		double b1=Double.parseDouble(s1);//Double.parseDouble()将字符串类型转换成double
		//int,double->String
		int a2=12;
		double b2=12.5;
		String s2=String.valueOf(a2);//String.valueOf()可以将各种数据类型转变成字符串类型
		String ss2=String.valueOf(b2);		
	}
}

计算程序运行时间

public class MainClass {
	public static void main(String[] args) {
		long time1=System.currentTimeMillis();
		for(int i=0;i<=100000000;i++) ;//为了让程序执行一段时间
		long time2=System.currentTimeMillis();
		System.out.println(time2-time1);		
	}
}

显示系统时间

import java.util.Calendar;
import java.util.Date;
public class MainClass {
	public static void main(String[] args) {	
		Date date=new Date();//没写参数时表示当前的系统时间
		System.out.println(date);
		Date date2=new Date(1000);//参数可以为一个long值，表示距离1970年1月1日8点0分0秒  1000毫秒的时间
		System.out.println(date2);
		long time=System.currentTimeMillis();//表示从1970年1月1日8点0分0秒到当前时间相差的毫秒数，是表示系统时间的一种表示方式
		System.out.println(time);
		Date date3=new Date(time);//参数可以为一个long值，表示距离1970年1月1日8点0分0秒  1000毫秒的时间
		System.out.println(date3);
		
		Calendar c=Calendar.getInstance();
		System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");		
	}
}

时间的格式化显示

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MainClass {
	public static void main(String[] args) {
		Date date=new Date();//没写参数时表示当前的系统时间

		System.out.println(date);//输出Mon Jan 06 11:17:09 CST 2020
		DateFormat df=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
		String s=df.format(date);
		System.out.println(s);//输出2020年01月06日 11:20:12

		DateFormat df2=new SimpleDateFormat("yyyy-MM-dd");
		String s2=df2.format(date);
		System.out.println(s2);//输出2020-01-06
	}
}

Java面向对象

1. 类与对象

public class People {//自定义的类类型，People是一个类类型，类类型是数据类型
	String name;//在类里面定义的变量叫字段、属性，表示的是类的特征
	String sex;
	int age;
	public void show() {
		System.out.println(name);//访问同一个类中的成员直接用成员名访问
	}
	public void play() {
		show();//调用同一个类的方法直接用方法名（）进行调用。
	}	
}

public class MainClass {
	public static void main(String[] args) {
		int x=1;//定义变量的语句：数据类型 变量名=变量值；
		People p=new People();//定义对象的语法结构：类名 对象名=new 类名（）；用类定义的变量叫对象，对象p是People类的一个实例
		//new People();叫实例化
		//访问对象成员的语句结构：对象名.成员名
		p.name="张三";
		p.sex="男";
		p.age=30;
	
		System.out.println(p.name); //访问不同类的成员：先创建类对象p,再通过对象名p.成员名进行访问
		p.show();//调用不同类的方法：先创建类对象，再通过对象名.方法名（）进行调用
	}
}


坦克大战游戏的部分代码：
package cn.gdsdxy;
public class Tank {//坦克类（我方坦克和敌方坦克）
	int x;//坦克在屏幕上的坐标,屏幕左上角的坐标为（0，0）
	int y;
	int direction;//表示坦克移动的方向,0表示向左
	public void left() {//坦克向左移
		if(x+5>0)
			x=x-5;		
	}
	public void fire() {
		Bullet objBullet=new Bullet();
		objBullet.x=x;//右边的x是坦克的x坐标，左边的x是子弹的坐标
		objBullet.y=y;
		if(direction==0) {//坦克的移动方向是向左
			while(子弹遇到障碍物或子弹超出屏幕范围) {
				objBullet.x -=5;
				Thread.sleep(50);//让线程停顿50毫秒
			}
		}
	}
}
class MyTank extends Tank{//我方坦克
}
class OtherTank extends Tank{//敌方坦克
}
class Bullet{//子弹类
	int x;
	int y;
}

2. 方法重载

public class Teacher {
	//方法重载是指一个类中可以包含多个同名方法，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。
	//只有方法类型不一样不能算方法重载，形参类型数量一样但名称不一样也不能算重载。
	//类中不允许出现不符合重载条件的同名方法。
	//注意：只有功能一样的方法才用相同的方法名，功能不一样的方法最好不要定义成相同的方法名。

	public void show() {
		System.out.println("无参数show方法");
	}
	public void show(String x) {
		System.out.println("有参数show方法");
	}
	public void show(int x) {
		System.out.println("有参数show方法");
	}
	public void add(int y,double x) {
		
	}
	public void add() {
		
	}
//	public int add(int y,double x) {
//		return 0;
//	}
}
public class MainClass1 {
	public static void main(String[] args) {
		//调用Teacher类的show()
		Teacher a=new Teacher();
		a.show();
		a.show(10);	
	}
}

3. 构造函数

方法名和类名一样的方法，并且这个方法没有方法类型，方法体中没有返回语句。构造方法在实例化的时候被自动调用（new的时候）。

构造函数的作用是用来对类的成员变量赋初值或完成一些初始化操作。

注意：如果程序员没有为类定义构造函数，系统将为类自定义一个无参数无实现的构造函数，如果程序员为类自定义构造函数，系统将不提供构造函数。特别强调：如果程序员在类中只定义有参数的构造函数，那么对该类进行实例化时要么要有参数，要么需要在类中增加一个无参数无实现的构造函数，否则会出错。

public class Student {
	String name;
	String sex;
	int age;
	public void Student() {//普通方法,普通方法最好不要跟类名相同
		System.out.println("这不是一个构造方法");
	}
	public Student(String name1,String sex1,int age1) {
		name=name1;
		sex=sex1;
		age=age1;
	}
	public Student() {//这是一个构造方法，方法名必须与类名相同，不能有return语句，不能写方法类型void
		System.out.println("这是一个构造方法");
	}
}
public class MainClass3 {
	public static void main(String[] args) {
		Student s=new Student();//new Student（）叫实例化，为类的成员开辟存储空间。实例化时会调用类的构造函数
		s.Student();
		Student s1=new Student("张三","男",30);//自动调用带参数的构造函数
		System.out.println(s1.name+s1.sex+s1.age);
	}
}

4. This关键字

什么情况下使用this关键字？

（1） 在一个非静态成员方法中，如果局部变量或形参与非静态成员变量名同名，只写变量名表示局部变量或形参，this.变量名表示成员变量。

public class MainClass {
    public static void main(String[] args) {
        Rectangle s=new Rectangle(1,2);
        System.out.println(s.area());
    }
}
public class Rectangle{
    public double length;
    public double width;
    public Rectangle(double length,double width){
        this.length=length;  //this.length表示成员变量length,  length表示参数length
        this.width=width;
    }
    public double area(){
        return length*width;
    }
}

（2） 在类的构造函数中，通过this语句调用该类的另一个构造函数。

例如：

public class MainClass {
    public static void main(String[] args) {
        Rectangle s=new Rectangle(1,2);
        System.out.println(s.area());
    }
}
public class Rectangle{
    public double length;
    public double width;
    public Rectangle(double length){
        this.length=length;
        this.width=length;
    }
    public Rectangle(double length,double width){
        this(length);//调用一个形参的构造函数
        this.width=width;
    }
    public double area(){
        return length*width;
    }
}

注意事项：
利用this调用构造函数时，this语句必须作为方法体的第一条语句。

（3） 表示当前对象，在一个方法调用中，使用this将当前实例的引用作为参数进行传递，或者把this作为返回值。

package cn.gdsdxy;
public class SquareClass{//正方形类
	double length;//边长属性
	public SquareClass getMaxSquare(SquareClass square) {//比较两个正方形大小的方法，SquareClass square要比较的另外一个正方形对象
		//因为返回值是this或square，他们的类型都是SquareClass,所以上面方法的类型用SquareClass。
	    if(this.length>square.length)
	    	return this;//返回当前的正方形对象
	    else
	    	return square;//返回另外一个正方形对象
	}
}

package cn.gdsdxy;
public class SquareMain {
	public static void main(String[] args) {
		SquareClass s1=new SquareClass();
		s1.length=10;
		SquareClass s2=new SquareClass();
		s2.length=20;
		SquareClass s=s1.getMaxSquare(s2);//对于这个调用语句来说，当跳转到getMaxSquare()方法，this就是指s1,square就是指s2
		System.out.println("最大的正方形的边长是"+s.length);
		SquareClass s0=s2.getMaxSquare(s1);//对于这个调用语句来说，当跳转到getMaxSquare()方法，this就是指s2,square就是指s1
		System.out.println("最大的正方形的边长是"+s0.length);
	}
}

5. 访问修饰符

package cn.gdsdxy;
public class PublicDemo {
	public String a="aa";//public 在任何位置都能访问
	private String b="bb";//private只能在当前类中被访问
	String c="cc";//缺省访问修饰符 只能在同一个包的任何位置被访问
	public void show() {
		System.out.println(a);//都在类的内部进行访问，可以访问
		System.out.println(b);
		System.out.println(c);
	}
}

package cn.gdsdxy;
public class MainClass {
	public static void main(String[] args) {
		PublicDemo p=new PublicDemo();
		p.a="aaa";
		//p.b="bbb";//错误，私有成员（private成员）不能被类的外部访问
		p.c="ccc";
	}
}

package gdsdxy;
import cn.gdsdxy.PublicDemo;
public class MainClass {
	public static void main(String[] args) {
		PublicDemo p=new PublicDemo();
		p.a="aaa";
		//p.b="bbb";//错误，私有成员（private成员）不能被类的外部访问
		//p.c="ccc";//错误，缺省访问修饰符的成员不能在包的外部被访问
	}
}

6. get方法和set方法

类中的成员变量一般不能被外部直接访问，类成员变量的访问修饰符一般都是private。通过get方法读取成员变量的值，set方法设置成员变量的值。

package cn.gdsdxy;
public class Student {
	private String name;//类中的成员变量一般不能被外部直接访问，类成员变量的访问修饰符一般都是private
	private String sex;
	private int age;
	private int number;
	public void setNumber(int number) {
		this.number=number;
	}
	public int getNumber() {
		return number;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}	
}
package cn.gdsdxy;
public class MainClass {
	public static void main(String[] args) {
		Student s=new Student();
		s.setName("张三");//与s.name="张三"功能等价。因为name是private类型，在类的外部不能通过s.name="张三";直接赋值
		System.out.println(s.getName());
		s.setNumber(10);
		System.out.println(s.getNumber());
	}
}

7. 静态方法/类方法static

方法调用的简单记忆法：

同一个类中的调用直接写方法名()。(在静态方法中调用非静态方法不能用这方法)

在不同类中调用普通方法：对象名.方法名（）；调用静态方法：类名.方法名（）

public class StaticFunDemo {
	public void show() {
		System.out.println("这是一个普通方法");
	}
	public static void play() {
		System.out.println("这是一个静态方法/类方法");
	}
	public void fun() {
		//调用同一个类的静态方法和非静态方法：“方法名（）”直接调用
		show();
		play();
	}
	public static void funation() {
		StaticFunDemo o=new StaticFunDemo();
		o.show();//注意：在静态方法中调用同一个类的非静态方法：先创建对象，再通过“对象名.方法名（）”调用
		
		play();
	}
}
public class StaticMain {
	public static void main(String[] args) {
		//调用不同类的普通方法：先创建对象，再通过“对象名.方法名（）”调用
		StaticFunDemo o=new StaticFunDemo();
		o.show();//调用其他类的普通方法
		//调用不同类的静态方法：用“类名.方法名()”调用
		StaticFunDemo.play();//调用不同类的静态方法		
	}
}

8. 静态变量/类变量

在类的成员方法声明中含有static关键字的方法称为静态方法，也叫类方法。

调用静态方法可用类名.方法名()或对象名.方法名()，通常采用类名.方法名()的调用方式。

public class StaticField {
	String name;//普通字段/属性:用来存放类对象的特征,对于每一个对象来说，每一个普通变量都是独立的存储空间
	static int count;//静态变量/类变量：用来存放类对象公有的特征，或者用来在多个类对象中传递数据。一个类就只有一个静态变量的存储空间，该空间给同一个类的多个对象共享
}
public class MainClass2 {
	public static void main(String[] args) {
		StaticField obj1=new StaticField();
		obj1.name="张三";//访问普通变量：对象名.成员名
		StaticField.count=1;//访问类变量/静态变量：类名.成员名     或        对象名.成员名
		obj1.count=1;
		
		StaticField obj2=new StaticField();
		obj2.name="李四";//访问普通变量：对象名.成员名
		obj2.count=2;
		
		System.out.println(obj1.name+obj1.count);
		System.out.println(obj2.name+obj2.count);
	}
}

9. 静态代码块

在类中可以用static修饰代码块，它不存在于任何方法中。JVM加载类时会按照它们在类中的顺序依次执行这些静态代码块，静态代码块只执行一次。

静态代码块的主要作用是初始化变量。

public class StaticClass1 {
	static {//static代码块
		System.out.println("这是静态代码块");		
	}
}
public class MainClass {
	public static void main(String[] args) {
       StaticClass1 p=new StaticClass1();//只有在类第一次加载的时候调用static代码块
	}
}

10. toString方法

toString方法用来将一个对象转成字符串的描述方式。

public class People {
	String name;
	int age;
	String sex;
	@Override
	public String toString() {
		return "姓名："+name+",性别："+sex+",年龄:"+age;
	}
}
public class MainClass {
	public static void main(String[] args) {
		People p=new People();		p.name="张三";		p.age=21;		p.sex="男";		
		System.out.println("姓名："+p.name+",性别："+p.sex+",年龄:"+p.age);
		System.out.println(p.toString());
		System.out.println(p);//直接写对象名会默认调用类中的toString()
	}
}

11. 内部类访问外部类的成员：

成员内部类可以无条件直接访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问： 外部类名.this.成员变量 /成员方法

public class Outer {//外部类
	public String a="外部类的a";
	public String b="外部类的b";
	public void show() {
		System.out.println("这是外部类的方法");
	}
	public void show1() {
		System.out.println("这是外部类的方法");
	}
	class Inner{//内部类,内部类是外部类的一个成员
		public String a="内部类的a";
		public void show() {
			System.out.println("这是内部类的方法");
		}
		public void fun() {
			System.out.println(a);//输出内部类的a
			show();//调用内部类的show()
			//访问外部类的同名成员的语法：外部类名.this.变量名/方法名（）
			System.out.println(Outer.this.a);//输出外部类的a
			Outer.this.show();//调用外部类的show()
			//在内部类没有出现要访问的同名成员就可以直接访问外部类的成员
			System.out.println(b);//访问外部类的成员b
			show1();//调用外部类的成员show1()
		}
	}
}

12. 外部类访问内部类的成员

在外部类访问内部类的成员：先用内部类创建对象，再通过对象名.成员名进行访问

public class OuterClass {//在外部类访问内部类的成员：先用内部类创建对象，再通过对象名.成员名进行访问
	public void show() {
		InnerClass o=new InnerClass();
		System.out.println(o.m);
	}
	class InnerClass{
		private String m="内部类的成员";
	}
}

13. 外部类的外部访问外部类中的内部类成员

public class OuterMain {
	public static void main(String[] args) {
//		Outer o=new Outer();
//		Outer.Inner i=o.new Inner();
		//上面两个语句等价于
		Outer.Inner i=new Outer().new Inner();//外部类名.内部类名  对象名=new 外部类名（）.new 内部类名（）；
		i.fun();
	}
}

14. 外部类的外部访问静态内部类

public class OuterClass {
	static class InnerClass{
		private String m="静态内部类";
	}
	class Inner{
		private String m="普通内部类";
	}

}
public class OuterMain {
	public static void main(String[] args) {
		//在外部类的外部访问内部类的方法：外部类名.内部类名  对象名=new 外部类名（）.new 内部类名（）；
//		OuterClass o=new OuterClass ();
//		OuterClass.Inner i=o.new Inner();
		//上面两个语句等价于
		OuterClass.Inner i=new OuterClass ().new Inner();
		i.fun();
		//在外部类的外部访问静态内部类的方法：外部类名.内部类名  对象名=new 外部类名.内部类名（）；
		OuterClass.InnerClass ii=new OuterClass.InnerClass();
	}
}

15. 在静态方法中访问同一个类的非静态成员（特殊情况）

public class OuterClass {
	public void fun() {
		//在外部类访问内部类的成员：先用内部类创建对象，再通过对象名.成员名进行访问
		InnerClass i=new InnerClass();
		System.out.println(i.name);
		i.show();
	}
	public static void fun1() {
		//在静态方法中访问同一个类的非静态成员都要按访问不同类的成员的方式进行访问
		//1.创建内部类对象：外部类名.内部类名 对象名=new 外部类名().new 内部类名();
		//2.通过对象名.成员名进行访问
		OuterClass.InnerClass i=new OuterClass().new InnerClass();
		System.out.println(i.name);
		i.show();
	}
	public class InnerClass{
		private String name;
		public void show() {
			System.out.println("内部类的方法");
		}
	}
}

16. 继承

extends关键字用于继承类。

声明一个继承父类的类的通常形式如下：

class 子类名 extends 父类名 {

​ //类体

}

注意：

（1） 没有extends，默认父类为Object

（2） 只能有一个父类，即单继承

public class People {
	String name;
	String sex;
}
public class Student extends People {//Student从People继承下来，Student是子类、派生类，People是父类、基类
	//默认包含了父类定义的name成员和sex成员
//	String name;
//	String sex;
	int number;
}
public class MainClass {
	public static void main(String[] args) {
		Student s=new Student();
		s.name="张三";
		s.sex="男";
		s.number=1;
	}
}

17. 访问修饰符

public任何地方都能访问

private只能在当前类中被访问

缺省类型：在同一个包中被访问

protected:在同一个包中被访问，在不同包的派生类（子类）中被访问

实例
package gdsdxy.edu.cn.package1;
public class FatherClass {
	public String a;
	String b;
	private String c;
	protected String e;
	void Show1()	{    //在当前类中可以访问public、private、protected和友好成员
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(e);
	}
}

package gdsdxy.edu.cn.package1;
public class SonClass extends FatherClass {  //同一包的子类
	String d;
	void Show2(){
		System.out.println(a);
		System.out.println(b);
		//System.out.println(c);  //错误
		System.out.println(e);
		System.out.println("d="+d);
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SonClass objSon=new SonClass();
		//调用父类的成员和方法
		objSon.a="aaaaa";
		objSon.b="bbbbb";
		//objSon.c="ccccc";  //错误，在同一个包的子类中能访问父类的非private成员
		objSon.e="eeeee";
		objSon.Show1();
		//调用子类的成员和方法
		objSon.d="ddddd";
		objSon.Show2();
	}

}

package gdsdxy.edu.cn.package2;
import gdsdxy.edu.cn.package1.FatherClass;
public class SonClass2 extends FatherClass {  //不同包的子类
	void show2()	{
		System.out.println(a);
		//System.out.println(b);  //b为友好成员，不能在不同的包中被访问
		//System.out.println(c);
		System.out.println(e);
	}
}


package gdsdxy.edu.cn.package2;
import gdsdxy.edu.cn.package1.FatherClass;
public class Class2 {  //不同包的非子类
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FatherClass objFather=new FatherClass();
		System.out.println(objFather.a);
		//System.out.println(objFather.b);  //错误，友好成员，在不同的包中不能被访问
		//System.out.println(objFather.c);  //错误，Private成员
		//System.out.println(objFather.e);  //错误，protected成员，只能在不同包的子类中被访问
	}
}

18. 成员变量（属性）隐藏和方法覆盖

子类可以直接使用父类的非私有方法，如果在子类中定义了与父类同名同参数的方法，这时父类的方法被隐藏起来，这就叫方法覆盖（也叫方法重写、方法隐藏）。

属性隐藏是指在子类中定义了与父类同名的变量，这时父类的同名变量被隐藏起来。

public class FatherClass {
	String name="Tom";
	void Show(){
		System.out.println("父类的方法");
	}
}
public class SonClass extends FatherClass{
	String name="Mike";
	void Show(){ //与父类的Show()方法同名，隐藏了父类的方法	
		System.out.println("子类的方法");
	}
	public static void main(String[] args) {
		SonClass objson=new SonClass();
	    System.out.println(objson.name);
	    objson.Show(); 
	}
}
屏幕输出：
Mike
子类的方法

19. 子类的构造函数

在实例化子类对象时，系统会调用子类的构造函数，并且把调用父类无参数构造函数的语句作为子类构造函数的第一个语句。

public class Father1 {
	public Father1() {
		System.out.println("这是父类的无参数构造函数");
	}	
	public Father1(String a) {
		System.out.println("这是父类的有参数构造函数");
	}
}
public class Son1 extends Father1{
	public Son1() {
		//子类的构造函数的第一个语句都是调用父类的构造函数，
		//默认情况下会调用父类的无参数构造函数
		//如果想调用有参数的构造函数就得用super(参数)去调用
//		super("aaa");//在构造函数中用来调用父类的构造函数
		System.out.println("这是子类的构造函数");
	}	
}
public class MainClass2 {
	public static void main(String[] args) {
		Son1 s=new Son1();
	}
}

20. 抽象类和抽象方法

public abstract class Media {
	public Media() {	//抽象类可以包含构造函数
	}
	public void play1() {//抽象类可以包含普通方法
		//如果{}中没有任何内容的表示这个方法不做任何操作
	}
	public abstract void play();
	//这方法还没有定义方法体，意味着这方法不知道要完成什么功能
}
public class CD extends Media{
	@Override
	public void play() {
		System.out.println("播放CD");		
	}
}
public class MainClass3 {
	public static void main(String[] args) {		
		//Media m=new Media();//抽象类不能被实例化
		Media m=new CD();
		m.play();
	}
}

21. 接口

public interface IMath {
	String name="1班";
	void show();
}
public class Math implements IMath {//Math叫接口IMath的实现类
	@Override
	public void show() {
		System.out.println("实现接口中的方法");
	}
}
public class MainClass4 {
	public static void main(String[] args) {
		//IMath o=new IMath();//接口不能实例化		
		System.out.println(IMath.name);//通过接口类型直接访问接口中的常量
		IMath o=new Math();//用接口类型创建接口对象，用接口的实现类进行实例化，将实例化的结果赋值给接口对象
		o.show();
	}
}

22. 异常处理

import java.util.InputMismatchException;
import java.util.Scanner;
public class ExceptionDemo {
	public static void main(String[] args) {
		int a,b;
		Scanner input=new Scanner(System.in);
		try {//把可能产生异常的代码放在try中
			a=input.nextInt();
			b=input.nextInt();
			int c=a/b;//当异常产生时，try代码块中该语句后面的语句不执行
			System.out.println(c);
		}catch(Exception e) {
			System.out.println("产生异常");
		}
		System.out.println("程序结束");
		input.close();
	}
}

23. 对不同异常做不同的处理

import java.util.InputMismatchException;
import java.util.Scanner;
public class ExceptionDemo {
	public static void main(String[] args) {
		int a,b;
		Scanner input=new Scanner(System.in);
		try {//把可能产生异常的代码放在try中
			a=input.nextInt();
			b=input.nextInt();
			int c=a/b;//当异常产生时，try代码块中该语句后面的语句不执行
			System.out.println(c);
		}catch(ArithmeticException e) {//把处理异常的代码放在catch中
			System.out.println("除数为0异常");
		}catch(InputMismatchException e) {
			System.out.println("输入不匹配异常");
		}catch(Exception e) {
			System.out.println("产生异常");
		}finally {
			System.out.println("不管有没有异常产生都会执行的代码");
		}
		System.out.println("程序结束");
		input.close();
	}
}

24. finally

public class ThrowsDemo {
	public static void fun() {
		try{
			return;//本来在方法中遇到return就立刻返回主调方法，finally语句比较特殊，尽管它定义在return后面它也会执行
		}
		finally{
			System.out.println("Finally");
		}
	}
	public static void main(String[] args) {
			fun();
	}
}

25. 处理方法异常的两种方法

public class ThrowsDemo {
	//处理方法异常的第一种方法：在方法中处理异常
	public static int div1(int a,int b) {
		int c=0;
		try {
			c=a/b;
		}catch(Exception e) {
			System.out.println("除数不能为0");
		}
		return c;
	}
	//处理方法异常的第二种方法：在方法中不处理异常，在方法声明中抛出异常，要由调用该方法的主调方法处理异常
	public static int div2(int a,int b) throws Exceptionn{
		int c=a/b;	
		return c;
	}
	public static void main(String[] args) {
		int c1=div1(2,1);//因为在方法中已经处理异常，所以调用方法的语句不用处理异常
			
		try {
			//main方法调用了div2方法，所以main方法是主调方法，主调方法要处理异常，把调用div2()的语句放在try中，通过catch处理异常
			int c2=div2(2,0);
		}catch (Exception e) {
			System.out.println("div2方法产生异常");
		}
	}
}

窗体编程：

26. 窗体的基本代码

import java.awt.Color;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
public class MyFrame extends JFrame {//JFrame是一个窗体类，MyFrame是继承下来的窗体类
	public MyFrame() {//构造函数
		setSize(400,300);//设置窗体大小
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//关闭当前窗体
		setVisible(true);//设置窗体可视，该语句一般放在最后面
	}
	public static void main(String[] args) {
		new MyFrame();//创建一个窗体对象
	}
}

27. 窗体的属性设置

import java.awt.Color;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
public class MyFrame extends JFrame {//JFrame是一个窗体类，MyFrame是继承下来的窗体类
	public MyFrame() {//构造函数
		setSize(400,300);//设置窗体大小
//		setLocation(200,400);//设置窗体位置
		setTitle("这是自定义的窗体");//设置窗体标题
		setLocationRelativeTo(null);//设置窗体显示在屏幕的正中间
//		setResizable(false);//设置窗体不可改变大小
//		setBounds(200,400,500,300);
//		setExtendedState(JFrame.MAXIMIZED_BOTH);//设置窗体最大化显示
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//关闭当前窗体
		//ImageIcon image=new ImageIcon("book.jpg");//创建图标对象，如果直接写文件名表示该图片文件放在项目的根目录
//		ImageIcon image=new ImageIcon("image\\book.jpg");//创建图标对象，图片文件放在项目的image文件夹中
		ImageIcon image=new ImageIcon("f:\\book.jpg");//创建图标对象，图片文件放在f盘根目录
		setIconImage(image.getImage());//设置窗体显示图标
		getContentPane().setBackground(Color.YELLOW);//设置窗体的背景颜色为黄色
		setVisible(true);//设置窗体可视，该语句一般放在最后面
	}
	public static void main(String[] args) {
		new MyFrame();//创建一个窗体对象
	}
}

28. 菜单

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

public class MyFrame extends JFrame {//JFrame是窗体类，MyFrame是自定义的窗体类
	public MyFrame() {//构造函数中一般用来设置窗体自身的属性，如：窗体的位置、大小、背景颜色等
		init();
		setSize(600,400);//设置窗体的大小600*400
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//关闭当前窗体		
		setVisible(true);//设置窗体可视化，该语句一般放在构造函数最后一个语句的位置
	}	
	//窗体上的控件的代码一般放在init()
	private void init() {//该方法名称可以任意定义，一般用初始化的单词作为方法名,该方法一般在构造函数的第一个语句的位置进行调用
		//创建菜单对于的控件对象
		JMenuBar objBar=new JMenuBar();
		JMenu objMenu=new JMenu("文件");
		JMenu editMenu=new JMenu("编辑");
		JMenu saveMenu=new JMenu("保存");
		JMenuItem objItem=new JMenuItem("打开");		
		JMenuItem cutItem=new JMenuItem("剪切");
		JMenuItem copyItem=new JMenuItem("复制");		
		JMenuItem saveItem=new JMenuItem("保存");
		JMenuItem saveAsItem=new JMenuItem("另存为");
		//设置控件对象之间的关联
		this.setJMenuBar(objBar);//给窗体添加菜单栏
		objBar.add(objMenu);//把菜单添加到菜单栏上
		objBar.add(editMenu);
		objMenu.add(objItem);//把菜单项添加到菜单上
		objMenu.add(saveMenu);
		saveMenu.add(saveItem);
		saveMenu.add(saveAsItem);
		editMenu.add(cutItem);
		editMenu.add(copyItem);		
	}
	public static void main(String[] args) {
		new MyFrame();  
	}
}



import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.KeyStroke;
public class MenuDemo extends JFrame {
	public MenuDemo() {
		init();
		setExtendedState(JFrame.MAXIMIZED_BOTH);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
	}
	private void init() {//该方法名可以任意定义，一般用初始化的单词作为方法名,该方法用来定义窗体上的控件/组件
		JMenuBar bar=new JMenuBar();//创建菜单栏
		JMenu menu=new JMenu("文件");//创建菜单
		JMenuItem openItem=new JMenuItem("打开");//创建菜单项		
		JMenu saveMenu=new JMenu("保存");//创建菜单
//		JMenuItem saveItem=new JMenuItem("保存",new ImageIcon("images\\book.jpg"));//创建菜单项
		JMenuItem saveItem=new JMenuItem("保存");//创建菜单项
//		saveItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D,InputEvent.SHIFT_MASK));//shift+D
		saveItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D,InputEvent.ALT_MASK|InputEvent.CTRL_MASK));//ctrl+alt+D
//		saveItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D,0));//D
		JMenuItem saveAsItem=new JMenuItem("另存为");//创建菜单项
//		saveAsItem.setIcon(new ImageIcon("images\\book.jpg"));
		JMenu editMenu=new JMenu("编辑");
		//设置关联
		this.setJMenuBar(bar);//设置窗体的菜单栏为bar
		bar.add(menu);//将文件菜单添加到菜单栏上
		bar.add(editMenu);
		menu.add(openItem);//将打开菜单项添加到文件菜单上
		menu.add(saveMenu);
		saveMenu.add(saveItem);
		saveMenu.addSeparator();
		saveMenu.add(saveAsItem);
		
		
		openItem.addActionListener(new ActionListener() {//事件处理程序			
			@Override
			public void actionPerformed(ActionEvent e) {
				JOptionPane.showMessageDialog(null, "用户点击了“打开”菜单项");				
			}
		});
		saveItem.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
				JOptionPane.showMessageDialog(null, "用户点击了“保存”菜单项");				
			}
		});
		saveAsItem.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				
			}
		});
	}
	public static void main(String[] args) {
		new MenuDemo();

	}

}

29. 边框布局BorderLayout

import java.awt.BorderLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class MyFrame extends JFrame {//JFrame是窗体类，MyFrame是自定义的窗体类
	public MyFrame() {//构造函数中一般用来设置窗体自身的属性，如：窗体的位置、大小、背景颜色等
		init();
		setSize(600,400);//设置窗体的大小600*400
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//关闭当前窗体		
		setVisible(true);//设置窗体可视化，该语句一般放在构造函数最后一个语句的位置
	}	
	//窗体上的控件的代码一般放在init()
	private void init() {//该方法名称可以任意定义，一般用初始化的单词作为方法名,该方法一般在构造函数的第一个语句的位置进行调用
		//窗体默认的布局方式是BorderLayout（边框布局），该布局把容器划分为东、南、西、北和中部5个区域，分别使用静态常量字段EAST、SOUTH、WEST、NORTH和CENTER标识。
		JButton btn1=new JButton("1");
		JButton btn2=new JButton("2");
		JButton btn3=new JButton("3");
		JButton btn4=new JButton("4");
		JButton btn5=new JButton("5");
		JButton btn6=new JButton("6");
		this.add(btn1,BorderLayout.EAST);//把按钮放在边框布局的东部
		this.add(btn2,BorderLayout.WEST);//把按钮放在边框布局的西部
		this.add(btn3,BorderLayout.NORTH);//把按钮放在边框布局的北部
		this.add(btn4,BorderLayout.SOUTH);//把按钮放在边框布局的南部
//		this.add(btn5,BorderLayout.CENTER);//把按钮放在边框布局的中部
//		this.add(btn6,BorderLayout.CENTER);//把按钮放在边框布局的中部
		//this.add(btn5);//把按钮放在边框布局的中部
		//每个区域最多只能（直接）放置一个组件。如果一个区域要放置两个以上的组件，可先把这些组件放进一个面板中，然后再把面板放置在区域中（容器嵌套）。
		JPanel panel=new JPanel();//JPanel是一个面板类，面板是一个容器，里面可以放各种控件
		panel.add(btn5);
		panel.add(btn6);
		this.add(panel,BorderLayout.CENTER);
		//如果东南西北四个区域都没有组件，则CENTER组件自动填满整个容器
	}
	public static void main(String[] args) {
		new MyFrame();  
	}
}

30. 流布局和网格布局

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
public class MyFrame extends JFrame {//JFrame是窗体类，MyFrame是自定义的窗体类
	public MyFrame() {//构造函数中一般用来设置窗体自身的属性，如：窗体的位置、大小、背景颜色等
		init();
//		setExtendedState(JFrame.MAXIMIZED_BOTH);
		setSize(600,400);//设置窗体的大小600*400
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//关闭当前窗体	
		//窗体默认的布局方式是BorderLayout（边框布局），改变窗体的布局方式得用：容器类对象.setLayout(new 布局类型());
//		setLayout(new FlowLayout());//把窗体改为流布局
		setLayout(new GridLayout(3,2,5,5));//把窗体改为网格布局,3行2列的网格
		setVisible(true);//设置窗体可视化，该语句一般放在构造函数最后一个语句的位置
	}	
	//窗体上的控件的代码一般放在init()
	private void init() {//该方法名称可以任意定义，一般用初始化的单词作为方法名,该方法一般在构造函数的第一个语句的位置进行调用
		
		JButton btn1=new JButton("1");
		JButton btn2=new JButton("2");
		JButton btn3=new JButton("3");
		JButton btn4=new JButton("4");
		JButton btn5=new JButton("5");
		JButton btn6=new JButton("6");
		this.add(btn1);
		this.add(btn2);
		this.add(btn3);
		this.add(btn4);
		this.add(btn5);
		this.add(btn6);
	}
	public static void main(String[] args) {
		new MyFrame();  
	}
}

31. 盒式布局

import java.awt.FlowLayout;
import javax.swing.*;
public class BoxDemo extends JFrame {
	public BoxDemo(){
		init();
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setLayout(new FlowLayout());//一般情况下，使用盒子进行布局通常会将窗体的布局改为流布局
		setVisible(true);
	}
	private void init() {
		Box hBox1=Box.createHorizontalBox();//创建一个水平盒子，往水平盒子上放控件，控件都显示在同一行上
		Box hBox2=Box.createHorizontalBox();//创建一个水平盒子，往水平盒子上放控件，控件都显示在同一行上
		Box vBox=Box.createVerticalBox();//创建一个垂直盒子
		
		JLabel lblUsername=new JLabel("姓名");
		JLabel lblPassword=new JLabel("密码");
		JTextField txtUsername=new JTextField(10);
		JTextField txtPassword=new JTextField(10);
		
		hBox1.add(lblUsername);
		hBox1.add(Box.createHorizontalStrut(10));//水平盒子上添加水平间距10
		hBox1.add(txtUsername);
		
		hBox2.add(lblPassword);
		hBox2.add(Box.createHorizontalStrut(10));//水平盒子上添加水平间距10
		hBox2.add(txtPassword);
		
		vBox.add(Box.createVerticalStrut(10));//垂直盒子上添加垂直间距10
		vBox.add(hBox1);
		vBox.add(Box.createVerticalStrut(10));//垂直盒子上添加垂直间距10
		vBox.add(hBox2);
		
		this.add(vBox);		
	}
	public static void main(String[] args) {
		new BoxDemo();
	}
}

32. 自定义面板类

import javax.swing.JButton;
import javax.swing.JPanel;
//JPanel是一个可以放控件的容器，默认情况下没有放控件
//SonPanel是JPanel的子类，所以SonPanel也是一个可以放控件的容器
public class SonPanel extends JPanel{
	public SonPanel() {
		JButton btn1=new JButton("1");
		JButton btn2=new JButton("2");
		this.add(btn1);//this是面板对象，通过该代码往面板容器中放控件
		this.add(btn2);
	}
}

import javax.swing.*;
public class BoxDemo2 extends JFrame {
	public BoxDemo2(){
		init();
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		SonPanel panel=new SonPanel();
		this.add(panel);
	}
	public static void main(String[] args) {
		new BoxDemo2();
	}
}

33. 添加读者信息面板的设计

import javax.swing.*;
public class BoxDemo extends JFrame {
	public BoxDemo() {
		init();
		setLayout(new FlowLayout());//用盒子容器进行布局通常要把窗体的布局方式设置为流布局
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
//		Box hBox1=Box.createHorizontalBox();//创建水平盒子
//	
//		Box vBox=Box.createVerticalBox();//创建垂直盒子
//		
//		JLabel lblName=new JLabel("读者姓名：");
//		JLabel lblSex=new JLabel("性别：");
//		JTextField txtName=new JTextField(10);
//		JTextField txtSex=new JTextField(10);
//		
//		hBox1.add(lblName);
//		hBox1.add(Box.createHorizontalStrut(10));
//		hBox1.add(txtName);
//		hBox1.add(Box.createHorizontalStrut(20));
//		hBox1.add(lblSex);
//		hBox1.add(Box.createHorizontalStrut(10));
//		hBox1.add(txtSex);
//
//		
//		vBox.add(Box.createVerticalStrut(10));
//		vBox.add(hBox1);
		
//		JPanel panel=new JPanel();
//		AddReaderPane panel=new AddReaderPane();
//		panel.add(vBox);
		
		AddReaderPane panel=new AddReaderPane();
		
		this.add(panel);
		
	}
	public static void main(String[] args) {
		new BoxDemo();
	}
}

import javax.swing.Box;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
//JPanel是没放控件的容器，AddReaderPane是带控件的容器
public class AddReaderPane extends JPanel {
	public AddReaderPane() {
		Box hBox1=Box.createHorizontalBox();//创建水平盒子
		
		Box vBox=Box.createVerticalBox();//创建垂直盒子
		
		JLabel lblName=new JLabel("读者姓名：");
		JLabel lblSex=new JLabel("性别：");
		JTextField txtName=new JTextField(10);
		JTextField txtSex=new JTextField(10);
		
		hBox1.add(lblName);
		hBox1.add(Box.createHorizontalStrut(10));
		hBox1.add(txtName);
		hBox1.add(Box.createHorizontalStrut(20));
		hBox1.add(lblSex);
		hBox1.add(Box.createHorizontalStrut(10));
		hBox1.add(txtSex);

		
		vBox.add(Box.createVerticalStrut(10));
		vBox.add(hBox1);
		//this指当前的面板容器，添加vBox后意味着当前面板是带有控件的面板
		this.add(vBox);
	}
}

34. 标签框

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class ControlDemo extends JFrame {
	public ControlDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JLabel lblName=new JLabel("姓名");
//		JLabel lblName=new JLabel();
//		lblName.setText("姓名");//控件对象.setText("要显示的字符串");设置控件上显示的内容		
		JButton btnOk=new JButton("Ok");		
		JLabel lblShow=new JLabel();//创建没有显示内容的标签框
		this.add(lblName);
		this.add(btnOk);
		this.add(lblShow);
		
		btnOk.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
				String name=lblName.getText();//控件对象.getText()可以用来获取控件上显示的内容
				lblShow.setText(name);//控件对象.setText()用来设置控件上显示的内容，将要显示的内容放在方法的括号中
			}
		});
	}
	
	public static void main(String[] args) {
		new ControlDemo();
	}
}

35. 文本框

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class ControlDemo extends JFrame {
	public ControlDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JTextField txtInput=new JTextField(10);
		JButton btnOk=new JButton("ok");
		JLabel lblOutput=new JLabel();
		JTextField txtOutput=new JTextField(10);
		txtOutput.setEditable(false);//设置文本框不可编辑
		txtOutput.setHorizontalAlignment(JTextField.CENTER);//设置文本框中文本的对齐方式
		this.add(txtInput);
		this.add(btnOk);
		this.add(lblOutput);
		this.add(txtOutput);
		
		btnOk.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				String s=txtInput.getText();//控件对象.getText()可以用来获取控件上显示的内容
				lblOutput.setText(s);//控件对象.setText()用来设置控件上显示的内容
				txtOutput.setText(s);
			}
		});
	}
	
	public static void main(String[] args) {
		new ControlDemo();
	}
}

36. 密码框

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class ControlDemo extends JFrame {
	public ControlDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JPasswordField txtInput=new JPasswordField(10);
		JButton btnOk=new JButton("ok");
		JLabel lblOutput=new JLabel();

		this.add(txtInput);
		this.add(btnOk);
		this.add(lblOutput);

		
		btnOk.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
//				String s=txtInput.getText();//控件对象.getText()可以用来获取控件上显示的内容
				//密码框最好不要用getText()获取控件上的内容，这样不安全
				//一般用密码框控件.getPassword()获取用户输入的密码
				//txtInput.getPassword()返回值是char[],要通过String.valueOf()进行类型转换
				String p=String.valueOf(txtInput.getPassword());
				lblOutput.setText(p);//控件对象.setText()用来设置控件上显示的内容				
			}
		});
	}
	
	public static void main(String[] args) {
		new ControlDemo();
	}
}

37. 改变控件显示大小和关闭窗体的代码

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class ControlDemo extends JFrame {
	public ControlDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JPasswordField txtInput=new JPasswordField(10);
		JButton btnOk=new JButton("ok");
		JLabel lblOutput=new JLabel();

		txtInput.setPreferredSize(new Dimension(150,40));//控件对象.setPreferredSize(new Dimension(宽度,高度))可以改变控件显示的大小
		btnOk.setPreferredSize(new Dimension(80,40));
		
		this.add(txtInput);
		this.add(btnOk);
		this.add(lblOutput);

		
		btnOk.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
//				dispose();//关闭当前窗体
				System.exit(0);//关闭所有窗体
			}
		});
	}	
	public static void main(String[] args) {
		new ControlDemo();new ControlDemo();
	}
}

38. 标签框、文本框、密码框、按钮

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class ControlDemo extends JFrame {
	public ControlDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JLabel lblName=new JLabel();
		JTextField txtName=new JTextField(20);
		txtName.setText("请输入姓名");
		txtName.setPreferredSize(new Dimension(200,50));//设置控件的大小
		txtName.setEditable(true);//设置控件可不可编辑
		JPasswordField txtPassword=new JPasswordField(20);
		JButton btnOk=new JButton("Ok");
		btnOk.setPreferredSize(new Dimension(80,40));
		btnOk.setEnabled(true);//设置控件能不能使用
		
		
		this.add(txtName);
		this.add(txtPassword);
		this.add(btnOk);
		this.add(lblName);
		
		btnOk.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
//				String s=txtName.getText();//getText()用来获取控件上显示的内容
//				String s2=String.valueOf(txtPassword.getPassword());//getPassword()用来获取密码框输入的内容，返回值是char[]
//				//String.valueOf()可以将括号中的数据类型转换成字符串类型
//				lblName.setText(s+s2);//将字符串s的内容作为标签框lblName的显示内容
				//上面的代码等价于下面的代码
//				String s=txtName.getText();//getText()用来获取控件上显示的内容
//				lblName.setText(s);//将字符串s的内容作为标签框lblName的显示内容
//				String s2=String.valueOf(txtPassword.getPassword());//getPassword()用来获取密码框输入的内容，返回值是char[]
//				lblName.setText(lblName.getText()+s2);
				
//				String name=txtName.getText();
//				String password=String.valueOf(txtPassword.getPassword());
//				if(    &&   ) {//省略了条件表达式
//					JOptionPane.showMessageDialog(null,"用户名密码正确");
//					lblName.setText("用户名密码正确");
//				}
				
				dispose();//关闭当前窗体
				System.exit(0);//关闭所有窗体
			}
		});
	}
	
	public static void main(String[] args) {
		new ControlDemo();
	}
}

39. 复选框、字体样式设置

import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JRadioButton;
public class RadioDemo extends JFrame {
	public RadioDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
//		getContentPane().setBackground(Color.RED);
		setVisible(true);
		
	}
	private void init() {
		JCheckBox b1=new JCheckBox("加粗");
		JCheckBox b2=new JCheckBox("倾斜");
	
		JButton btnOk=new JButton("Ok");
		JLabel lblShow=new JLabel("程序设计");
//		b1.setSelected(true);
//		b2.setSelected(true);
//		b3.setSelected(true);
		this.add(b1);
		this.add(b2);

		this.add(btnOk);
		this.add(lblShow);

		
		btnOk.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
//				lblShow.setFont(new Font("黑体",0,24));//new Font()的第一个参数是字体（黑体、宋体），第二个参数是字体样式（加粗、倾斜，0表示不加粗不倾斜），第三个参数是字体大小
//				lblShow.setFont(new Font("黑体",Font.ITALIC,24));//Font.ITALIC表示倾斜
//				lblShow.setFont(new Font("宋体",Font.ITALIC|Font.BOLD,16));
				//Font.ITALIC表示倾斜  Font.BOLD表示加粗，Font.ITALIC|Font.BOLD表示既加粗又倾斜
				
				String f=lblShow.getFont().getFamily();//获取标签框的字体类型是宋体还是黑体等等
				int size=lblShow.getFont().getSize();//获取标签框的字体大小
				int style=0;//不加粗不倾斜
				if(b1.isSelected())
					style |= Font.BOLD;
				if(b2.isSelected())
					style |= Font.ITALIC;
				lblShow.setFont(new Font(f,style,size));
			}
		});
	}
	public static void main(String[] args) {
		new RadioDemo();
	}
}

40. 组合框

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class BoxDemo extends JFrame {
	public BoxDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JComboBox<String> cbx=new JComboBox<String>();
		cbx.addItem("语文");
		cbx.addItem("数学");
		cbx.setPreferredSize(new Dimension(150,30));
		cbx.setEditable(true);//设置控件可以编辑	
		JButton btnOk=new JButton("ok");
		JLabel lblResult=new JLabel();
		
		JComboBox<Integer> cbx2=new JComboBox<Integer>();//<String>用来指明组合框中元素的数据类型 .  Integer是int对于的类类型
		for(int i=1;i<=12;i++)
			cbx2.addItem(i);
		
		JComboBox<String> cbx1=new JComboBox<String>();//<String>用来指明组合框中元素的数据类型 .  Integer是int对于的类类型
		for(int i=1;i<=12;i++)
			cbx1.addItem(i+"");//数值类型与字符串类型相加等到的数据类型是字符串类型
		
		this.add(cbx);
		this.add(cbx1);
		this.add(cbx2);
		this.add(btnOk);
		this.add(lblResult);		
		
		btnOk.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
				String s=String.valueOf(cbx.getSelectedItem());//cbx.getSelectedItem()获取组合框中输入的内容或选中的项目
				lblResult.setText(s);				
			}
		});		
		
	}
	public static void main(String[] args) {
		new BoxDemo();
	}
}

41. 文本域

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class BoxDemo extends JFrame {
	public BoxDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JTextArea txtInput=new JTextArea();		
		txtInput.setLineWrap(true);//设置自动换行
		//给文本域txtInput添加滚动条要用滚动面板
		JScrollPane pane=new JScrollPane(txtInput);//该语句等价于JScrollPane pane=new JScrollPane();pane.setViewportView(txtInput);	
		pane.setPreferredSize(new Dimension(250,100));//通过设置滚动面板的大小来设置文本域的大小
		this.add(pane);//将滚动面板添加到窗体上，不能用this.add(txtInput);
//		txtInput.setEditable(false);//设置文本域不可编辑
		JButton btnOk=new JButton("ok");
		JLabel lblResult=new JLabel();	
		this.add(btnOk);
		this.add(lblResult);		
		
		btnOk.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
//				txtInput.append("123\n");	//往文本域中追加内容
//				txtInput.insert("567", 0);  //在文本域最前面添加内容
				String s=txtInput.getText();
				lblResult.setText(s);
			}
		});			
	}
	public static void main(String[] args) {
		new BoxDemo();
	}
}

42. 组合框和文本域的实验内容

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class BoxDemo extends JFrame {
	public BoxDemo() {
		init();
		setLayout(new FlowLayout());
		setSize(600,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JComboBox<String> cbx=new JComboBox<String>();
		cbx.addItem("1班");
		cbx.addItem("2班");
		
		JTextArea txtInput=new JTextArea(4,30);	
		JButton btnOk=new JButton("ok");
		
		this.add(cbx);
		this.add(btnOk);
		this.add(txtInput);
		btnOk.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				txtInput.append("班级："+cbx.getSelectedItem());
				
			}
		});
	}
	public static void main(String[] args) {
		new BoxDemo();
	}
}

43. 列表框

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.ListSelectionModel;

public class ListDemo extends JFrame {
	public ListDemo(){
		init();	
		this.setLayout(new FlowLayout());
		this.setTitle("XX号XXX");
		this.setBounds(100, 200, 400, 400);     
		this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		this.setVisible(true);					
	}	
	public void init(){		
		String[] data= {"语文","数学","英语"};
		JList<String> list1=new JList<String>(data);//创建一个带内容的列表框
		JList<String> list2=new JList<String>();//创建一个无内容的列表框,<>中的数据类型要与列表项的数据类型一致
		list2.setListData(data);//设置列表框的内容
		JList<Object> list3=new JList<Object>();//创建一个无内容的列表框
		list1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);//设置列表框单选
	    list2.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);//设置列表框可以连续多选		
JButton btnOk=new JButton("add");
		
		this.add(list1);
		this.add(list2);
		this.add(btnOk);
		this.add(list3);
		
		btnOk.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				String s=list1.getSelectedValue();//获取列表框中选中的列表项
				Object[] o=list2.getSelectedValues();//获取列表框中选中的多个列表项
				String a="";
				for(int i=0;i<o.length;i++) {//o.length表示数组的元素个数
					a+=String.valueOf(o[i]);//o[i]表示列表框中选中的项
				}
				JOptionPane.showMessageDialog(null, s+a);
				list3.setListData(o);//o是Object类型，所以list3在定义时要用JList<Object> list3=new JList<Object>();
			}
		});
	}
	public static void main(String[] args) {
		new ListDemo();
	}
}

44. 列表框的格式设置和列表项的动态添加

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;

public class ListDemo extends JFrame {
	public ListDemo(){
		init();	
		this.setLayout(new FlowLayout());
		this.setTitle("XX号XXX");
		this.setBounds(100, 200, 400, 400);     
		this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		this.setVisible(true);					
	}	
	public void init(){		
		JList<String> list1=new JList<String>();//创建一个无内容的列表框
		//如果要动态的改变列表框的列表项，就得用DefaultListModel
		DefaultListModel<String> model1=new DefaultListModel<String>();
		model1.addElement("1");//给列表框模板添加列表项
		model1.addElement("2");
		model1.addElement("3");
		model1.addElement("4");
		model1.addElement("5");
		list1.setModel(model1);//设置列表框与模板的关联
		JList<String> list2=new JList<String>();//创建一个无内容的列表框
		DefaultListModel<String> model2=new DefaultListModel<String>();
		list2.setModel(model2);	
		
		JButton btnOk=new JButton("add");
		JScrollPane pane=new JScrollPane(list1);//要自定义列表框的格式就得给列表框添加滚动面板
		list1.setVisibleRowCount(5);//设置可以显示5个列表项
		list1.setFixedCellHeight(25);//设置列表项的高度
		list1.setFixedCellWidth(80);//设置列表项的宽度
		
		JScrollPane pane2=new JScrollPane(list2);
		list2.setVisibleRowCount(5);//设置可以显示5个列表项
		list2.setFixedCellHeight(25);
		list2.setFixedCellWidth(80);
		
		this.add(pane);//当一个控件添加滚动条后，要在窗体中添加控件应该添加滚动面板而不是直接添加控件
		this.add(btnOk);
		this.add(pane2);
		
		btnOk.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
				Object[] l=list1.getSelectedValues();
				for(int i=0;i<l.length;i++) {
					model2.addElement(l[i].toString());
					model1.removeElement(l[i]);
				}				
			}
		});
	}
	public static void main(String[] args) {
		new ListDemo();
	}
}

45. 列表框的格式设置和列表项的动态添加

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;

import javafx.scene.control.SelectionModel;

public class JListDemo2 extends JFrame {
	public JListDemo2() {
		init();
		setLayout(new FlowLayout());
		setSize(700,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {

		JList<String> list1=new JList<String>();
//		String[] data= {"语文","数学","英语"};
//		list1.setListData(data);
		
		JScrollPane pane=new JScrollPane(list1);//给列表框添加滚动条
		list1.setVisibleRowCount(8);//设置列表框中显示的列表项的数目
		list1.setFixedCellWidth(150);//设置列表项的宽度
		list1.setFixedCellHeight(30);//设置列表项的高度
		this.add(pane);//将滚动面板添加到窗体上，而不是将列表框添加到窗体上
		
		//要动态添加列表项的话得用DefaultListModel模板
		DefaultListModel<String> model1=new DefaultListModel<String>();
		list1.setModel(model1);//设置列表框与模板关联
		model1.addElement("语文");//往模板中添加列表项，相当于是往列表框中添加列表项
		model1.addElement("数学");
		model1.addElement("英语");
		
		JButton btnOk=new JButton("Ok");
		this.add(btnOk);
		
		JList<String> list2=new JList<String>();		
		this.add(list2);
		//要动态添加列表项的话得用DefaultListModel模板
		DefaultListModel<String> model2=new DefaultListModel<String>();
		list2.setModel(model2);//设置列表框与模板关联
		
		
		btnOk.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
				//下面的代码用来添加和删除一个列表项
//				String s=list1.getSelectedValue();//list1.getSelectedValue()用来获取列表框中选中的列表项
//				model2.addElement(s);//把字符串s添加到与model2关联的list2上，作为list2的列表项
//				model1.removeElement(s);//删除与mode1关联的list1上内容为s的列表项
				
				//下面的代码用来添加和删除多个列表项
				Object[] datas=list1.getSelectedValues();//list1.getSelectedValues()用来获取列表框中选中的所有列表项
				for(int i=0;i<datas.length;i++) {
					model2.addElement(String.valueOf(datas[i]));
					model1.removeElement(String.valueOf(datas[i]));
				}
			}
		});
	}
	public static void main(String[] args) {
		new JListDemo2();

	}

}

46. 表格

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
public class ControlDemo extends JFrame {
	JTable objTable;//因为该对象要给init()和MyListener类使用，所以要定义在类的里面，方法的外面
	DefaultTableModel objModel;
	public ControlDemo() {
		init();
		setSize(700,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JLabel lblName=new JLabel("姓名");
		JLabel lblChinese=new JLabel("语文");
		JLabel lblMath=new JLabel("数学");
		JLabel lblEnglist=new JLabel("英语");
		JTextField txtName=new JTextField(10);
		JTextField txtChinese=new JTextField(10);
		JTextField txtMath=new JTextField(10);
		JTextField txtEnglish=new JTextField(10);
		JButton btnAdd=new JButton("添加");
		JButton btnDelete=new JButton("删除");
		JButton btnUpdate=new JButton("修改");
		
		Box boxH1=Box.createHorizontalBox();
		Box boxH2=Box.createHorizontalBox();
		Box boxV=Box.createVerticalBox();
		
		boxH1.add(lblName);boxH1.add(txtName);boxH1.add(Box.createHorizontalStrut(30));
		boxH1.add(lblChinese);boxH1.add(txtChinese);boxH1.add(Box.createHorizontalStrut(30));
		boxH1.add(lblMath);boxH1.add(txtMath);boxH1.add(Box.createHorizontalStrut(30));
		boxH1.add(lblEnglist);boxH1.add(txtEnglish);
		boxH2.add(btnAdd);boxH2.add(Box.createHorizontalStrut(30));
		boxH2.add(btnDelete);boxH2.add(Box.createHorizontalStrut(30));
		boxH2.add(btnUpdate);
		boxV.add(boxH1);boxV.add(Box.createVerticalStrut(10));
		boxV.add(boxH2);boxV.add(Box.createVerticalStrut(10));
		
		JPanel pane1=new JPanel();
		pane1.add(boxV);
		 
		this.add(pane1,BorderLayout.NORTH);
		
		String[] fields= {"姓名","语文","数学","英语"};
		String[][] data= {{"张三","85","90","80"},{"李四","95","93","90"}};
		objTable=new JTable();
		objModel=(DefaultTableModel)objTable.getModel();//获取表格对应的模板
		objModel.setDataVector(data,fields);//设置表格模板的内容
		JScrollPane pane=new JScrollPane(objTable);//将表格放在滚动面板中，不用滚动面板没法显示表头行信息
		pane.setPreferredSize(new Dimension(400,300));//设置表格的大小
		this.add(pane);
		
		objTable.getTableHeader().setPreferredSize(new Dimension(150,40));//改变表格表头行的高度
		objTable.setRowHeight(40);//改变表格数据行的高度
		
		btnDelete.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
				int i=objTable.getSelectedRow();//获取在表格中选中的行的索引号
//				objModel.removeRow(0);//表示删除表格的第一行数据
				objModel.removeRow(i);//表示删除表格的第i+1行数据
				
			}
		});
		objTable.addMouseListener(new MouseListener() {			
			@Override
			public void mouseReleased(MouseEvent e) {
				// TODO Auto-generated method stub				
			}			
			@Override
			public void mousePressed(MouseEvent e) {//在表格中按下鼠标所做的操作
				int i=objTable.getSelectedRow();//获取在表格中选中的行的索引号
				String s1=objTable.getValueAt(i, 0).toString();//获取表格第i+1行第1列的内容
				txtName.setText(s1);
				String s2=objTable.getValueAt(i, 1).toString();//获取表格第i+1行第2列的内容
				txtChinese.setText(s2);
				String s3=objTable.getValueAt(i, 2).toString();//获取表格第i+1行第3列的内容
				txtMath.setText(s3);
				String s4=objTable.getValueAt(i, 3).toString();//获取表格第i+1行第4列的内容
				txtEnglish.setText(s4);
			}
			@Override
			public void mouseExited(MouseEvent e) {
				// TODO Auto-generated method stub
				
			}
			
			@Override
			public void mouseEntered(MouseEvent e) {
				// TODO Auto-generated method stub
				
			}
			
			@Override
			public void mouseClicked(MouseEvent e) {
				// TODO Auto-generated method stub
				
			}
		});
		btnUpdate.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {				
				int i=objTable.getSelectedRow();//获取表格中选中的行的索引号
				String name=txtName.getText();//获取姓名输入框的内容
				objTable.setValueAt(name, i, 0);//设置表格第i+1行第1列的内容为name
				String chinese=txtChinese.getText();//获取语文输入框的内容
				objTable.setValueAt(chinese, i,1);//设置表格第i+1行第2列的内容为chinese
				//后面的数学和英语成绩的代码自己写
			}
		});
		
		//事件编程的第二步：给事件源注册监听器对象。作用：使点击“添加”按钮时执行MyListener类中的事件处理程序
		btnAdd.addActionListener(new MyListener());//btnAdd是事件源，MyListener是自定义的监听器类

		
		btnAdd.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
//				String[] row= {"王五","80","90","70"};
				String[] row= {txtName.getText(),txtChinese.getText(),txtMath.getText(),txtEnglish.getText()};
				objModel.addRow(row);//往表格中添加行				
			}
		});
	}	
	public static void main(String[] args) {
		new ControlDemo();
	}
	//事件编程的第一步：自定义监听器类
	class MyListener implements ActionListener{//自定义的监听器类
		@Override
		public void actionPerformed(ActionEvent e) {//事件处理程序
			int i=objTable.getSelectedRow();//获取在表格中选中的行的索引号
//			objModel.removeRow(0);//表示删除表格的第一行数据
			objModel.removeRow(i);//表示删除表格的第i+1行数据
			
		}
		
	}
	
}

47. 事件编程

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
public class ControlDemo extends JFrame {
	JTable objTable;//因为该对象要给init()和MyListener类使用，所以要定义在类的里面，方法的外面
	DefaultTableModel objModel;
	public ControlDemo() {
		init();
		setSize(700,400);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
	private void init() {
		JLabel lblName=new JLabel("姓名");
		JLabel lblChinese=new JLabel("语文");
		JLabel lblMath=new JLabel("数学");
		JLabel lblEnglist=new JLabel("英语");
		JTextField txtName=new JTextField(10);
		JTextField txtChinese=new JTextField(10);
		JTextField txtMath=new JTextField(10);
		JTextField txtEnglish=new JTextField(10);
		JButton btnAdd=new JButton("添加");
		JButton btnDelete=new JButton("删除");
		JButton btnUpdate=new JButton("修改");
		
		Box boxH1=Box.createHorizontalBox();
		Box boxH2=Box.createHorizontalBox();
		Box boxV=Box.createVerticalBox();
		
		boxH1.add(lblName);boxH1.add(txtName);boxH1.add(Box.createHorizontalStrut(30));
		boxH1.add(lblChinese);boxH1.add(txtChinese);boxH1.add(Box.createHorizontalStrut(30));
		boxH1.add(lblMath);boxH1.add(txtMath);boxH1.add(Box.createHorizontalStrut(30));
		boxH1.add(lblEnglist);boxH1.add(txtEnglish);
		boxH2.add(btnAdd);boxH2.add(Box.createHorizontalStrut(30));
		boxH2.add(btnDelete);boxH2.add(Box.createHorizontalStrut(30));
		boxH2.add(btnUpdate);
		boxV.add(boxH1);boxV.add(Box.createVerticalStrut(10));
		boxV.add(boxH2);boxV.add(Box.createVerticalStrut(10));
		
		JPanel pane1=new JPanel();
		pane1.add(boxV);
		 
		this.add(pane1,BorderLayout.NORTH);
		
		String[] fields= {"姓名","语文","数学","英语"};
		String[][] data= {{"张三","85","90","80"},{"李四","95","93","90"}};
		objTable=new JTable();
		objModel=(DefaultTableModel)objTable.getModel();//获取表格对应的模板
		objModel.setDataVector(data,fields);//设置表格模板的内容
		JScrollPane pane=new JScrollPane(objTable);//将表格放在滚动面板中，不用滚动面板没法显示表头行信息
		pane.setPreferredSize(new Dimension(400,300));//设置表格的大小
		this.add(pane);
		
		btnAdd.addActionListener(new ActionListener() {			
			@Override
			public void actionPerformed(ActionEvent e) {
//				String[] row= {"王五","80","90","70"};
				String[] row= {txtName.getText(),txtChinese.getText(),txtMath.getText(),txtEnglish.getText()};
				objModel.addRow(row);//往表格中添加行				
			}
		});

		
		//事件编程的第二步：给事件源注册监听器对象。作用：使点击“添加”按钮时执行MyListener类中的事件处理程序
		btnAdd.addActionListener(new MyListener());//btnAdd是事件源，MyListener是自定义的监听器类
		
	}	
	//事件编程的第一步：自定义监听器类
	class MyListener implements ActionListener{//自定义的监听器类
		@Override
		public void actionPerformed(ActionEvent e) {//事件处理程序
			int i=objTable.getSelectedRow();//获取在表格中选中的行的索引号
//			objModel.removeRow(0);//表示删除表格的第一行数据
			objModel.removeRow(i);//表示删除表格的第i+1行数据
			
		}
		
	}
	public static void main(String[] args) {
		new ControlDemo();
	}

}