笔记(课2)

一阶段：第二天：选择语句+循环语句+方法（7.24）

一.选择语句

1. .程序基本结构：顺序结构，选择结构，循环结构
2. 扩展：

CA FE BA BE
在16进制打开字节码文件的情况下，若首行首字出现
这4个字符证明是java文件

javap:解析字节码文件
-c -v -p -l

javac：把java文件编译为class（字节码）文件
java：执行java程序

3. 字符串的比较是否相等，不能用“=”，应该用equals比较
4. int random=(int)(Math.random()*10); //随机数
   　注意：Math.random();产生0-1之间的一个数字，含0不含1
5. switch（表达式）：
   　（1）. 表达式expr的值必须是下述几种类型之一： byte、short、int、char、enum(枚举)；java7之后可以是String。
   　（2）case子句中的值const 必须是常量值(或final的变量)，case中的值不能是一个范围
   　（3）break语句用来在执行完一个case分支后使程序跳出switch语句块；否则会继续执行下去
   　（4）case穿透（特殊用法）： 产生这种现象的原因:由于某个case语句中缺少或者漏写break语句所导致的结果.（eg：可以用于打印输出指定的月份的天数）

// 需求: 打印输出指定的月份的天数 
Scanner sc = new Scanner(System.in); 
int month = sc.nextInt(); 
switch(month){ 
　　case 1: 
　　case 3: 
　　case 5: 
　　case 7: 
　　case 8: 
　　case 10: 
　　case 12: System.out.println("31天"); break; 
　　case 2: System.out.println("28天"); break; 
　　case 4: 
　　case 6: 
　　case 9: 
　　case 11: System.out.println("30天"); break; 
}
System.out.println("Hello World!"); 

6. 逻辑运算符和短路运算符的区别：

1）逻辑与：& 无论左端是否为false，右端都会执行。 
2）短路与：&& 只要左端是false，则右端不执行，结果都为false。 
1）逻辑或：| 无论左端是否为true，右端都会执行。
 2）短路或：|| 只要左端是true，则右端不执行，结果都为true。 

二.循环语句

1. 如果循环次数固定优先使用for ，如果次数不确定用while和do while
2. break:应用在switch和循环中，作用：跳出（终止）语句块 .
   continue:应用在循环中，作用：结束本次循环，继续下一次循环.
   return :用在方法中，作用是：返回结果，结束方法.

杨辉三角：
public class A20{
  public static void main(String args[]){
    Scanner input=new Scanner(System.in);
    System.out.println("请输入行数n");
    int row=input.nextInt();
    int[][]result=newint[row][row];
    for(inti=0;i<row;i++){
    //行for(intj=1;j<=row-i;j++){
        System.out.print("");
    }
    result[i][0]=1;System.out.print(result[i][0]+"");
    for(intj=1;j<=i;j++){
    //列result[i][j]=result[i-1][j-1]+result[i-1][j];
    System.out.print(result[i][j]+"");}
    System.out.println();
    }
  }
}

将String型转换成char型:
String n=input.next();
char ch[]=n.toCharArray();
char c=ch[0];

三.方法

1. 方法的作用：简化代码，提高代码的可读性，可维护性，可重用性。
2. 访问权限修饰符：public,default（默认）,private ,protected
3. 方法之间只能进行相互的调用，而不能在方法中声明方法，就目前而言声明的方法都和main方法时并列的
4. 方法的重载：同一个类中，方法名相同，方法参数列表不同
5. （1）参数是引用类型（eg：String），调用
   方法后参数值随方法改变
   （2）参数是基本类型（eg：int等），调用
   方法后参数值不随方法改变，还保持在main方
   法中初始化的值
6. 如果一个自定义的函数有返回值，并且在方法中遇到了分支结构，使用return 在每一个分支后面都需要出现一个return
7. 同一个类中，方法名字相同，参数列表不同。则是重载
8. 扩展：

运行时，会分配两个空间：栈和堆
(1)栈空间：比较小，存储速度快，jdk1.5之前256kjdk1.5之后1M
    特点：先进后出
    每调用一个方法都有进栈，执行结束出栈
(2)堆空间：比较大，存储速度慢，按照对象大小分配

递归：StackOverFlowError栈空间溢出
Stack：栈
一个方法占用一个栈帧

斐波那契数列 1,2,3,4,5,6, 7, 8, 9,10,11,..... 
　　　　　　1,1,2,3,5,8,13,21,34,55,89.... 
　　　　　　分析： 1.第一个位置和第二个位置上的数是固定的，都是1 
　　　　　　　　　2.第n个位置上的数 = 第n ‐ 1个位置上的数 + 第n ‐ 2个位置上的数
　　//需求：报个数，获取在斐波那契数列中对应的数 
　　public static int fun(int n) {
　　　　 if(n == 1 || n == 2) {
　　　　 　　 return 1; 
　　　　 } else {
　　　　 　　  return fun(n ‐ 1)+fun(n‐2); 
　　　　 }
　　 }

四.重要案例

4.1汉诺塔

3个圆盘A,B,C，在A的上面有n个从小到大排列的盘子，问怎么才能在每次只移动一个盘子的前提下，可以借助B，将A上的盘子挪放到C上，且在移动过程中和最后的结果，都必须是小盘子在上，大盘子在下，求移动过程

public class A1{
    public static void main(String[] args){
	move("A","B","C",2);
    }
    public static void move(String a,String b,String c,int num){
	if(num==1){
	    System.out.println(a+"---->"+c);
	    return;
	}
	move(a,c,b,num-1);
	System.out.print(a+"---->"+c);
	move(b,a,c,num-1);
    }
}

4.2猴子分桃

有5个猴子分一堆桃子，不可以平分，5个猴子都回去睡觉了，晚上，
第一个猴子深夜偷偷起来，丢掉一个桃子，正好可以5个人分，
于是，他拿掉自己的那份回去了。第二个猴子也起来了，又丢了个桃子，
又正好可以5个人分，于是，他也拿着自己的那份走了，
后面的3，4，5猴子都是用同样的方法，也都正好。
问：至少有几个桃子。

倒推：
public class A1{
    public static void main(String[] args){
	int num=5;//猴子的数目
	int n=1;//最后一只猴子的桃子数
	int startNum=0;
	for(int i=0;i<num;i++){
	    if(i==0){
		startNum=5*n+1;
	    }else{
		if(startNum%4!=0){
		    n++;
		    i=-1;
		}else{
		    startNum=5*(startNum/4)+1;
		}
	    }
	}
	System.out.println(startNum);
    }
}

正推：
public class A16{
    public static void main(String args[]){
       mm:for(int i=6;;i++){
         int x=i;
         boolean a=true;
         if(i%5==0){
           continue;
         }
         for(int j=1;j<=5;j++){
            x=x-1;
            if(x%5!=0){
                a=false;
                break;
            }
            x=x-x/5;
         }
         if(a){
           System.out.println("至少有"+i+"个桃子");
           break mm;
         }
       }
    }
}

逆推：
public class Demo1 {
    public static void main(String[] args) {
        int peach=6;//设置peach为桃子的数量最小值
        int count=0; //猴子的数量
        label:while(true){
            int temp=peach;//临时变量保存桃子的数量
            count=0;
            while((temp-1)%5==0){
                temp=(temp-1)*4/5;
                count++;
                if(count==5){//分了五次，5只猴子
                    break label;
                }
            }
            peach+=5;
        }
        System.out.println("peach："+peach);
    }
}

4.3杨辉三角

            1
          1   1
        1   2   1
      1   3   3   1
    1   4   6   4   1
  1   5  10   10  5   1
1   6  15   20  15  6   1
方法一：
public class Demo2 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入杨辉三角的行数");
        int line=input.nextInt();
        for(int i=0;i<line;i++){
            //输入空格
            int number=1;
            System.out.printf("%"+(line-i)*2+"s","");
            for(int j=0;j<=i;j++){
                System.out.printf("%4s",number);
                number=number*(i-j)/(j+1);
            }
            System.out.println();
        }
    }
}

方法二：
public class Demo3 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入杨辉三角的行数");
        int[][] nums=new int[10][];
        for(int i=0;i<nums.length;i++){
            //空格
            System.out.printf("%"+(nums.length-i)*2+"s","");
            //输出数字
            nums[i]=new int[i+1];
            for(int j=0;j<=i;j++){
                //赋值
                if(j==0||j==i){
                    nums[i][j]=1;
                }else{
                    nums[i][j]=nums[i-1][j]+nums[i-1][j-1];
                }
                System.out.printf("%4d",nums[i][j]);
            }
            System.out.println();
        }
    }
}