1.break和continue的区别：
break :
[1]switch中使用，作用跳出switch结构，停止贯穿
[2]循环结构中, 作用，退出循环结构
continue:
只能用在循环里 ，作用，结束当前循环，进入下一次循环
在while,do-while中跳转到条件判断处，在for中跳转到i++处
demo1;continue与break在二重循环中，只作用于本层循环
import java.util.Scanner;
public class TestCircle{
public static void main(String [] args){
Scanner input=new Scanner(System.in);
String answer="y";
while(true){
for(int i=0;i<3;i++){
System.out.println("请输入用户名:");
String userName=input.next();
System.out.println("请输入密码:");
String pwd=input.next();
/*if("admin".equals(userName)&&"admin".equals(pwd)){
System.out.println("登录成功!");
break; //在for中，作用是退出for
}
System.out.println("用户名或密码不正确，请重新录入!");
*/
if(!"admin".equals(userName)||!"admin".equals(pwd)){
System.out.println("用户名或密码不正确，请重新录入!");
continue;
}
System.out.println("登录成功!");
break;
}
System.out.println("继续吗?y/n");
answer=input.next();
if(!"y".equals(answer)){
break; //在while中，作用是退出while
}
}
}
}
demo2: 带标签的continue与break; 作用于标签处
import java.util.Scanner;
public class TestCircle2{
public static void main(String [] args){
Scanner input=new Scanner(System.in);
String answer="y";
a: while(true){
for(int i=0;i<3;i++){
System.out.println("请输入用户名:");
String userName=input.next();
System.out.println("请输入密码:");
String pwd=input.next();
/*if("admin".equals(userName)&&"admin".equals(pwd)){
System.out.println("登录成功!");
break; //在for中，作用是退出for
}
System.out.println("用户名或密码不正确，请重新录入!");
*/
if(!"admin".equals(userName)||!"admin".equals(pwd)){
System.out.println("用户名或密码不正确，请重新录入!");
continue a;
}
System.out.println("登录成功!");
break a;
}
/*System.out.println("继续吗?y/n");
answer=input.next();
if(!"y".equals(answer)){
break; //在while中，作用是退出while
}*/
}
}
}2.方法
用于完成一个独立的小功能的一段代码，只有被调用时才执行 ,而且可以被反复调用
方法的定义
[1]明确方法是否会有不确定的因素，不确定的因素作为形式参数
[2]明确方法的运行结束之后是否会有结果，如果有结果，结果应该是什么类型？这个类型作为方法的返回值
方法的调用
[1]负责提供实际参数
[2]负责处理结果
public class TestSystem{
public static void main(String [] args){
System.out. println ("hello"); //String
System.out. println (true); //boolean
System.out. println (89); //int
System.out. println ('c'); //char
System.out. println (90.8); //double
}
}
public class Calc {
public static int add ( int a,int b ){
System.out.println("亲，这里在执行加法运算");
return a+b;
}
public static double add ( double a,double b ){
return a+b;
}
public static double add ( int a,double b ){
return a+b;
}
}3.方法的重载
(1)在同一个类中
(2)方法的名称相同
(3)参数的列表不同（参数的个数，类型，顺序不同）
(4)与返回值类型和访问权限修饰符无关
*/
public static int add(int a,int b){
return a+b;
}
public static void add(int a,int b){
System.out.println(a+b);
}
public static void add(int a,int b,int c){
System.out.println(a+b+c);
}
public static double add(int c ,int d){
return c+d;
}
public static double add(int a,double b){
return a+b;
}
public static double add(double a,double b){
return a+b;
}
static double add(double a,double b){
return a+b;
}
public static int add1(int a,int b){
return a+b;
}
}4.递归
递归：就是自己调用自己
递归的前提条件：方法定义与调用
public class Recu{
public static int plus ( int number){
if(number==1){ //结束条件
return 1; //结束时的结果是什么
} else{ //自己调用自己
return plus(number-1)+number;
}
}
public static int plus2(int number){
int sum=0;
for(int i=1;i<=number;i++){
sum+=i;
}
return sum;
}
public static void main(String [] args){
System.out.println(plus(5));
System.out.println(plus(10));
System.out.println(plus(100));
System.out.println("----------------------------------\n");
System.out.println(plus2(5));
System.out.println(plus2(10));
System.out.println(plus2(100));
}
}斐波拉契数列
public class Bonacci{
public static int bonacci(int index){
if(index==1||index==2) { //结束时的值
//结束时的结果是什么
return 1;
}else{
//自己调用自己
return bonacci(index-1)+bonacci(index-2);
}
}
public static void main(String [] args){
//System.out.println(bonacci(12));
for(int i=1;i<=12;i++){
System.out.print(bonacci(i)+"\t");
}
}
}数组:
存储一组相同类型的有序数据
下标：从0开始，标识的是数据（元素）的位置
数组实际上也是一个变量，在内存中划出 一串连续 的空间
最大下标+1=数组中元素的个数(数组的长度)
数组的最大下标=数组的长度-1;
数组的使用: (4步)
[1]声明数组 数组类型[] 数组名; int [] array; -->栈内存进行的
[2](开辟)分配空间 数组名=new int [10]; -->堆内存进行的
[3]赋值 数组名[0]=9; -->堆内存
[4]使用 syto(数组名[0]);
public class TestArray{
public static void main(String [] args){
int [] array=null; //[1]声明数组
//将在堆内存中开辟的空间地址（复制一份）赋值给变量array
array=new int[10]; // [2]在堆内存开辟空间10个，用于存储10个整型数据
//[3]给数组中的元素赋值
array[0]=9;
//[4]将数组中的第一个元素打印输出
System.out.println( array[0] );
}
}数组的静态赋值：
public class TestArray2{
public static void main(String [] args){
int score[]={89,87,98}; //静态赋值
/*int [] score1;
score1={89,87,98}; 静态赋值，没有使用关键字new，则声明并赋值，必须在一行完成*/
int [] array=new int[]{98,34,45,3,4};
int [] array2;
array2=new int[]{98,34,45,3,4};
System.out.println(array2);
}
}数组的动态赋值：
int [] score = new int [5]; // 声明并分配空间
for ( int i =0; i <5; i ++){
System. out .println( " 请输入第 " +( i +1)+ " 个学生的成绩 " );
score[i] = input .nextInt();
// int s=input.nextInt();
}数组的正向遍历和逆向遍历：
正向遍历
public static void print(int [] array){
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"\t");
}
System.out.println("\n");
for(int num:array){
System.out.print(num+"\t");
} }
逆向遍历
public static void Rprint(int [] arr1){
for(int i= arr1.length-1 ;i>=0; i-- ){
System.out.print(arr1[i]+"\t");
}
}查找一个值在数组中是否存在：
public static boolean search(int number,int []arr){
for(int num:arr){
if(num==number){
return true;
}
}
return false;
}数组中的最值问题：
public static int getMax(int []arr){
int max=arr[0];//将数组中索引为0的元素赋给最值
for(int i=1;i<arr.length;i++){
//判断
if(arr[i]>max){
max=arr[i];
}
}
return max;
}二维数组：
二维数组存储是实际上是一维数组的内存地址，而且存储的一维数据的长度可以不相同。
public class TestArray {
public static void main(String [] args ){
int [] arr1 ={12,34,45}; // 一维数组
int [] arr2 = new int []{43,45}; // 一维数组
int [] arr3 ={65,67,85,98}; // 一维数组
// 把以上三个一维数组，放到一个数组中储
// 数据类型 [] 数组名称 =new 数据类型 [ 长度 ];
System. out .println( "arr1=" + arr1 + "\tarr2=" + arr2 + "\tarr3=" + arr3 );
int [] [] array=new int[3][];// 存储数组的数组，二维数组
System. out .println( "\n 赋值之前二维数组中的数据 " );
for ( int i =0; i < array . length ; i ++){
System. out .print( array [ i ]+ "\t" );
}
// 二维数组中存储的是三个一维数组的内存地址
array[0]=arr1;
array[1]=arr2;
array[2]=arr3;
System. out .println( "\n 赋值之后二维数组中的数据 " );
for ( int i =0; i < array . length ; i ++){
System. out .print( array [ i ]+ "\t" );
}
System. out .println( "\n 二维数组的遍历 " );
for ( int i =0; i < array . length ; i ++){ // 二维数组的长度
for ( int j =0; j < array[i].length ; j ++){ // 每个一维数组的长度
System. out .print( array[i][j] + "\t" );
}
System. out .println();
}
System. out .println( "\n 使用加强 for 循环 " );
for ( int [] arrayB : array ){ // 二维数组中所存储的数据类型是一维数组 int []
for ( int num : arrayB ){ // 一维数组中存储的数据类型是 int
System. out .print( num + "\t" );
}
System. out .println();
}
}
}