JAVA学习笔记Day02——基本语法

1、循环

while

循环条件会比循环体多执行一次

两种形式：

初始化
while(循环条件){
    循环体
    迭代
}

另一种

 初始化
while(循环条件，迭代){
    循环体
    迭代
}

do…..while

初始化
do{
    循环体
    迭代
}while(循环条件，迭代);

for

for循环中除了循环体，其他的都可以不写

条件不写：默认为true

    for(初始化;条件;迭代){
    循环体
}

for比while的优势：变量的生命周期，节省空间

用到的两个控制：

1. break;(跳出指定循环，如没有指定，则跳出当前循环)
2. continue;（跳出指定的本次循环，如没指定，则跳出最近的一次循环）

---

案例

判断100以内的素数

 public class Demo02{
 public static void main(String[] args){
     int sum = 0;
     int count = 0;
_L:
     for(int i = 2; i <= 100; i++){      
         boolean isPrime = true;

         for(int j = 2; j <= Math.sqrt(i); j++){
             count++;
             if(i % j == 0){
                 //isPrime = false;
                // break;
                //去掉isPrime的做法
                continue _L;            
     }
         }
         sum++;
         //if(isPrime){
             //sum++;
        // }

     }
     System.out.println("100以内的总个数为：" + sum);
     System.out.print("count = " + count);
 } 

}

---

2、方法

关键字修饰

不经常使用的

strictfp：strict float，point（意义不大，与gvm的实现有关，float的严格检查，可以修饰方法和类）
synchronized：同步
transient：修饰属性的，和序列化相关，修饰的属性不会被序列化，
volatile：只能修饰属性，善变的一种属性，最轻量级的线程锁
assert：断言，一般用于调试
native修饰方法，（本地方法），在java中没有方法体，在c语言中

修饰方法的：
abstract
final
native
private public protected
static
strictfp
synchronized

absract final 互斥不可一起使用

• 方法 格式：

• java只有单返回值

• 斐波纳契数列
  1、1、2、3、5、8、13、21……….
  F1 = F2 = 1,Fn= Fn-1 + Fn-2;

案例：

public class Demo03{
    public static void main(String[] args){
        System.out.println("fibonacci(3) = " + fibonacci(3));
        System.out.println("fibonacci(4) = " + fibonacci(4));
        System.out.println("fibonacci(5) = " + fibonacci(5));
        System.out.println("fibonacci(6) = " + fibonacci(6));

        int num1 = 1;
        int num2 = 2;
        for(int k = 3; k < 6; k++){
            int temp = num1 + num2;
            num1 = num2;
            num2 = temp;
        }
        System.out.println("sum = " + num2);

    }

    // [注解][修饰符] 返回值类型[泛型定义] 方法名（参数列表)[throws异常声明] 方法体
    // 值传递，不会改变外面的值
        private static int add(int i, int j){
            return i + j;
        }

        // 引用传递，会改变外面的值
        private static void swap(int[] i, int[] j){
            int temp = i[0];
            i[0] = j[0];
            j[0] = temp;
        }

        // 斐波纳契数列递归
        private static int fibonacci(int num){
            // 跳出递归的条件
            if(num == 1 || num == 2){
                return 1;
            }else{
                return fibonacci(num - 2) + fibonacci(num - 1);
            }
        }
}