关键字

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写

保留字

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字。
byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

标识符

标识符
- Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 凡是自己可以起名字的地方都叫标识符
定义合法标识符规则
- 由26个英文字母大小写，0-9 ，_或$组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含关键字和保留字
- Java中严格区分大小写，长度无限制
- 标识符不能包含空格
注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
Java中的名称命名规范
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

变量

基本概念

变量的概念
- 内存中的一个存储区域
- 该区域有自己的名称（变量名）和类型（数据类型）
- Java中每个变量必须先声明，后使用
- 该区域的数据可以在同一类型范围内不断变化
使用变量注意
- 变量的作用域：一对{ }之间有效
- 初始化值
定义变量的格式：数据类型变量名 = 初始化值
变量是通过使用变量名来访问这块区域的

程序的执行过程

变量的分类

对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

按数据类型

整数类型

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

浮点类型

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’
浮点型常量有两种表示形式：
- 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
- 科学计数法形式：如：5.12e2 512E2 100E-2

字符类型

char 型数据用来表示通常意义上“字符”(2字节)
字符型常量的三种表现形式：
- 字符常量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
- Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; （’\n’表示换行符）
- 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。
char类型是可以进行运算的。因为它都对应有Unicode码。

补充

ASCII码

在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 0000000 到 11111111。
ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
缺点：
- 不能表示所有字符
- 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)

Unicode编码

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。
缺点：
- Unicode 只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储
- 无法区别 Unicode 和 ASCII
- 计算机无法区分三个字节表示一个符号还是分别表示三个符号

UTF-8

UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。
UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。
UTF-8的编码规则：
- 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
- 对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为”10”，其余6位用来对字符进行编码。

布尔类型

boolean 类型适用于逻辑运算，一般用于程序流程控制：
- if条件控制语句
- while循环控制语句
- do-while循环控制语句
- for循环控制语句；
boolean类型数据只允许取值true和false，无null
- 不可以用 0 或非 0 的整数替代 false 和 true，这点和C语言不同

按声明的位置

在方法体外，类体内声明的变量称为成员变量
在方法体内部声明的变量称为局部变量

注意：二者在初始化值方面的异同：
- 同：都有生命周期
- 异：局部变量除形参外，需显式初始化

类型转换

自动类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
byte，short，char之间不会相互转换，他们三者在计算时首先转换为int类型。
当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。

强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符( )，但可能造成精度降低或溢出，格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
- 如： String a = “43”; int i = Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。

补充：String类

值null可以赋值给任何引用类型（类、接口、数组）的变量，用以表示这个引用类型变量中保存的地址为空。
String类属于引用类型，可用null赋值。
String类是一个典型的不可变类，String对象创建出来就不可能被改变。创建出的字符串将存放在数据区，保证每个字符串常量只有一个，不会产生多个副本。

练习1

String str1 = 4; //判断对错：错

String str2 = 3.5f + “”; //判断str2对错：对

System.out.println(str2); //输出：3.5

System.out .println(3+4+“Hello!”); //输出：7Hello!

System.out.println(“Hello!”+3+4); //输出：Hello!34

System.out.println(‘a’+1+“Hello!”); //输出：98Hello!

System.out.println(“Hello”+‘a’+1); //输出：Hello!a1

练习2

判断是否能通过编译

1）short s = 5; s = s-2; //判断：no

2）byte b = 3; b = b + 4; //判断：no

b = (byte)(b+4); //判断：yes

3）char c = ‘a’; int i = 5; double d = .314; double result = c+i+d; //判断：yes

4）byte b = 5; short s = 3; short t = s + b; //判断：no

进制

表示方式

二进制：0,1 ，满2进1，以0b或0B开头
十进制：0-9 ，满10进1
八进制：0-7 ，满8进1，以数字0开头表示
十六进制：0-9及A-F，满16进1，以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0

原码反码补码

所有数字在计算机底层都以二进制形式存在
计算机以补码的形式保存所有的整数
- 正数的原码、反码、补码都相同
- 负数的补码是其反码加1
原码：直接将一个数值换成二进制数。
反码：是对原码按位取反，只是最高位（符号位）确定为1。
Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位

进制转换

十进制二进制

二进制转成十进制乘以2的幂数
十进制转成二进制除以2取余数

二进制八进制十六进制

运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符
三元运算符

算术运算符

需要注意的问题：

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。取模后的符号取决于被模数。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：int x=3510; x=x/1000*1000; x的结果是？3000
“+”除字符串相加功能外，还能把非字符串转换成字符串。例如：System.out.println(“5+5=”+5+5); //打印结果是？
以下二者的区别：
- System.out.println( ‘*‘ + ‘\t’ +’*‘ )；——这个相当于做运算
- System.out.println( “*“ + ‘\t’ +’*‘ )；——这个相当于做连接

赋值运算符

符号：=
- 当“ = ”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
- 支持连续赋值
扩展赋值运算符： +=，-=， *=， /=， %=
思考1：short s = 3；

s=s+2； ①

s+=2； ②

①和②有什么区别？

①：编译会不通过，默认2为int型，会损失精度
②：在s本身的基础上+2，类型还是short，不需要强转
思考2：boolean b1 = false;

//区分好==和=的区别

if(b1=true)

System.out.println(“结果为真”)；

else

System.out.println(“结果为假”)；

思考3：int i = 1;

i *= 0.1;

System.out.println(i)；//0

比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false
比较运算符“==”不能误写成“=”

逻辑运算符

逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3<x<6，应该写成 x>3 & x<6
“&”和“&&”的区别：
- 单&时，左边无论真假，右边都进行运算
- 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
- 建议以后代码使用&&
“ | ” 和 “ | | ” 的区别同理，|| 表示：当左边为真，右边不参与运算，建议以后代码使用 | |
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false

位运算符

位运算是直接对二进制进行运算

左移右移

无符号右移

与/或

异或

反码

细节

三元运算符

格式：

表达式1和表达式2为同种类型
三元运算符与if-else的联系与区别：
- 三元运算符可简化if-else语句
- 三元运算符要求必须返回一个结果
- if 后的代码块可有多个语句

运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序
只有单目运算符、三元运算符、赋值运算符是从右向左运算的

面试题

写出输出的结果

//考查运算符的优先级
class Demo{
	public static void main(String[] args){
		int x=0,y=1;
		if(++x==y-- & x++==1||--y==0)
			System.out.println("x="+x+",y="+y);//x = 2,y = 0;
		else
			System.out.println("y="+y+",x="+x);
	}
}

int n = 5,m = 13;
//插入代码，实现n和m值的交换
System.out.println("n="+n+",m="+m);

[answer]

int n = 5,m = 13;
//int temp = n;
//n = m;
//m = temp;
System.out.println("n="+n+",m="+m);

//n = n + m;
//m = n - m;
//n = n - m;
System.out.println("n="+n+",m="+m);

n = n ^ m;
m = n ^ m ;
n = n ^ m;
System.out.println("n="+n+",m="+m);

如何手动实现整型数值60的二进制到十六进制的转换

String str1 = Integer.toBinaryString(60);
String str2 = Integer.toHexString(60);
int i1 = 60;
int i2 = i1&15;
String j = (i2 > 9)? (char)(i2-10 + 'A')+"" : i2+"";

int temp = i1 >>> 4;
i2 = temp & 15;
String k = (i2 > 9)? (char)(i2-10 + 'A')+"" : i2+"";
System.out.println(k+""+j);

写出输出结果

class Demo{
  	public static void main(String[] args){
  		int a=3,b=8;

      int c=(a>b)?a++:b++;
      System.out.println("a="+a+"\tb="+b+"\tc="+c);  

      int d=(a>b)?++a:++b;
      System.out.println("a="+a+"\tb="+b+"\td="+d);  

      int e=(a<b)?a++:b++;
      System.out.println("a="+a+"\tb="+b+"\te="+e);  

      int f=(a<b)?++a:++b;
      System.out.println("a="+a+"\tb="+b+"\tf="+f);  
    
    }
}

short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错

答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）

Java有没有goto

答：java中的保留字，现在没有在java中使用

用最有效率的方法算出2乘以8等于几

答：2 << 3

char型变量中能不能存储一个中文汉字?为什么?

答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

float型 float f=3.4是否正确?

答：不正确。精度不准确，应该用强制类型转换，如下所示：float f=(float)3.4

String是最基本的数据类型吗？

答：基本数据类型包括byte、int、char、long、float、double、boolean和short。java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。

程序流程控制

顺序结构
- 程序从上到下逐行地执行，中间没有任何判断和跳转
分支结构
- 根据条件，选择性地执行某段代码
- 有if…else和switch两种分支语句
循环结构
- 根据循环条件，重复性的执行某段代码
- 有while、do…while、for三种循环语句
- 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素

分支结构

if-else

if语句三种格式：

条件判断之间可以嵌套
如果多个条件之间是“互斥”关系，多个条件语句上下顺序是自由的
如果多个条件之间是“包含”关系，要求范围小的写在范围大的上面
如果语句是多条，要用 { } 括起来

练习

练习1：从键盘输入小明的期末成绩。当成绩为100分时，奖励一辆BMW；当成绩为（80，99]时，奖励一个台iphone5s；当成绩为[60,80]时，奖励一本参考书；其它时，什么奖励也没有。

import java.util.Scanner;

public class TestScore {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入小明的分数：");
        int score = scanner.nextInt();
        if (score == 100){
            System.out.println("奖励一辆BMW");
        }
        else if (score > 80 && score <= 90){
            System.out.println("奖励一个台iphone5s");
        }
        else if (score >= 60 && score <= 80){
            System.out.println("奖励一本参考书");
        }
        else {
            System.out.println("没有奖励哦，下次再接再厉哦～");
        }
    }
}

练习2：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。

import java.util.Scanner;

public class TestSort {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入num1的值：");
        int num1 = scanner.nextInt();
        System.out.print("请输入num2的值：");
        int num2 = scanner.nextInt();
        System.out.print("请输入num3的值：");
        int num3 = scanner.nextInt();

        if (num1 < num2){
            if (num3 < num1){
                System.out.println("排序结果为：" + num3 + num1 + num2);
            }
            else if (num3 > num2){
                System.out.println("排序结果为：" + num1 + num2 + num3);
            }
            else{
                System.out.println("排序结果为：" + num1 + num3 + num2);
            }
        }
        else {
            if (num3 > num1){
                System.out.println("排序结果为：" + num2 + num1 + num3);
            }
            else if (num3 < num2){
                System.out.println("排序结果为：" + num3 + num2 + num1);
            }
            else {
                System.out.println("排序结果为：" + num2 + num3 + num1);
            }
        }
    }
}

练习3：大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。如果这三个条件同时满足，则：“我一定要嫁给他!!!”；如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”；如果三个条件都不满足，则：“不嫁！”

import java.util.Scanner;

public class TestMarry {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入男生的身高(cm)：");
        int tall = scanner.nextInt();
        System.out.print("请输入男生的财产(千万)：");
        double money = scanner.nextDouble();
        System.out.print("请输入男生的颜值(帅否：true/false)：");
        boolean handsome = scanner.nextBoolean();

        if (tall >= 180 && money >= 1 && handsome == true){
            System.out.println("我一定要嫁给他!!!");
        }
        else if (tall >= 180 || money >= 1 || handsome == true){
            System.out.println("嫁吧，比上不足，比下有余。");
        }
        else{
            System.out.println("不嫁！");
        }
    }
}

switch

break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
如果没有break，会继续执行
default：可选的，而且位置是灵活的，当没有匹配的case时，执行default
switch(表达式)中表达式可以是哪些类型？——char、byte、short、int、枚举、String（jdk 1.7）
case条件：只能是值，不能是范围
当多个case语句处理的语句块相同时，可以统一来书写
一定情况下，switch-case与if-else之间可以相互转换

switch和if对比

if 和 switch 语句很像，具体什么场景下，应用哪个语句呢？

如果判断的具体数值不多，而且符合byte、 short 、int、 char这四种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

练习

练习1：使用 switch 把小写类型的 char 型转为大写。只转换 a, b, c, d, e. 其它的输出 “other”。

import java.util.Scanner;

public class TestCapital {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入字母：");
        char letter = scanner.next().charAt(0);

        switch (letter){
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            case 'd':
                System.out.println("D");
                break;
            default:
                System.out.println("other");
                break;
        }
    }
}

练习2：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

import java.util.Scanner;

public class TestScore2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入分数：");
        int score = scanner.nextInt();

        switch (score/10){
            case 10:
            case 9:
            case 8:
            case 7:
            case 6:
                System.out.println("合格");
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                System.out.println("不合格");
                break;
        }
    }
}

练习3：根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

import java.util.Scanner;

public class TestSeason {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入月份：");
        int month = scanner.nextInt();

        switch (month){
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
        }
    }
}

练习4：编写程序：从键盘上输入2014年的“month”和“day”，要求通过程序输出输入的日期为2014年的第几天。

import java.util.Scanner;

public class TestMonthDay {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入2014年中的某个月份：");
        int month = scanner.nextInt();
        System.out.print("请输入2014年中的某个月份中的某一天：");
        int day = scanner.nextInt();
        int total = 0;

        switch(month){
            case 12: total += 30;
            case 11: total += 31;
            case 10: total += 30;
            case 9: total += 31;
            case 8: total += 31;
            case 7: total += 30;
            case 6: total += 31;
            case 5: total += 30;
            case 4: total += 31;
            case 3: total += 28;
            case 2: total += 31;
            case 1: total += day;
        }
        System.out.println("这是2014年的第" + total + "天");
    }
}

练习5：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级，score>=90，等级：A，70=<score<90，等级: B，60=<score<70，等级: C，score<60，等级：D

import java.util.Scanner;

public class TestScore3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入学生的分数：");
        int score = scanner.nextInt();

        switch (score/10){
            case 10:
            case 9:
                System.out.println("等级：A");
                break;
            case 8:
            case 7:
                System.out.println("等级：B");
                break;
            case 6:
                System.out.println("等级：C");
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                System.out.println("等级：D");
                break;
        }
    }
}

练习6：从键盘分别输入年、月、日，判断这一天是当年的第几天。注：判断一年是否是闰年的标准： 1）可以被4整除，但不可被100整除。2）可以被400整除

import java.util.Scanner;

public class TestYearMonthDay {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入年份：");
        int year = scanner.nextInt();
        System.out.print("请输入月份：");
        int month = scanner.nextInt();
        System.out.print("请输入日期：");
        int day = scanner.nextInt();
        int total = 0;

        switch(month){
            case 12: total += 30;
            case 11: total += 31;
            case 10: total += 30;
            case 9: total += 31;
            case 8: total += 31;
            case 7: total += 30;
            case 6: total += 31;
            case 5: total += 30;
            case 4: total += 31;
            case 3:
                if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0 )){
                    total += 29;
                }else{
                    total += 28;
                }
            case 2: total += 31;
            case 1: total += day;
        }
        System.out.println("这是2014年的第" + total + "天");
    }
}

循环结构

循环语句功能
- 在某些条件满足的情况下，反复执行特定代码的功能
循环语句的四个组成部分
- 初始化部分（init_statement）
- 循环条件部分（test_exp）
- 循环体部分（body_statement）
- 迭代部分（alter_statement）
循环语句分类
- for 循环
- while 循环
- do/while 循环

for循环

语法格式

for ( 初始化表达式①; 布尔值测试表达式②⑤⑦; 更改表达式 )｛

语句或语句块③⑥；

｝

练习

练习1：编写程序FooBizBaz.java，从1循环到150并在每行打印一个值，另外在每个3的倍数行上打印出“foo”，在每个5的倍数行上打印“biz”，在每个7的倍数行上打印输出“baz”。

public class FooBizBaz {
    public static void main(String[] args) {
        for (int i = 1; i <= 150; i++){
            System.out.print(i);
            if (i % 3 == 0){
                System.out.print(" foo");
            }
            if (i % 5 == 0){
                System.out.print(" biz");
            }
            if (i % 7 == 0){
                System.out.print(" baz");
            }
            System.out.println();
        }
    }
}

练习2：打印1~100之间所有奇数的和。

public class TestOdd {
    public static void main(String[] args) {
        int total = 0;
        for (int i = 1; i <= 100; i++){
            if (i % 2 != 0){
                total += i;
            }
        }
        System.out.println(total);
    }
}

练习3：打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）

public class TestCount {
    public static void main(String[] args) {
        int number=0, total=0;
        for (int i= 1; i <= 100; i++){
            if (i % 7 == 0){
                number += 1;
                total += i;
            }
        }
        System.out.println("1-100内7的倍数的个数：" + number);
        System.out.println("1-100内7的倍数的总和：" + total);
    }
}

练习4：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 1 * 1 * 1 + 3 * 3 * 3 + 5 * 5 * 5

public class TestNarcissus {
    public static void main(String[] args) {
        for (int i = 100; i < 1000; i++){
            int bai = i / 100;
            int shi = (i % 100) / 10;
            int ge = i % 10;
            if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge){
                System.out.println(i);
            }
        }
    }
}

while循环

语法格式

[初始化语句]

while( 布尔值测试表达式)｛

语句或语句块；

[更改语句；]

}

do-while循环

语法格式

[初始化语句]

do｛

语句或语句块;

[更改语句;]

｝while(布尔值测试表达式);

练习

练习1：编写程序一：求1到100之间所有偶数的和。用while和do-while语句分别完成。

public class TestEven {
    public static void main(String[] args) {

        int i = 1;
        int total = 0;

      //while 语句
        while(i <= 100){
            if (i % 2 ==0){
                total += i;
            }
            i++;
        }
        System.out.println(total);

      //do-while 语句
        do {
            if (i % 2 == 0){
                total += i;
            }
            i++;
        }while (i <= 100);
        System.out.println(total);

    }
}

练习2：编写程序二：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

import java.util.Scanner;

public class TestPositiveNegative {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = 0; //记录正数的个数
        int b = 0; //记录负数的个数

        //for循环
        for (;;){
            System.out.print("请输入一个整数：");
            int num = scanner.nextInt();
            if (num > 0){
                a++;
            }
            else if (num < 0){
                b++;
            }
            else
                break;
        }

        //while循环
        while(true){
            System.out.print("请输入一个整数：");
            int num = scanner.nextInt();
            if (num > 0){
                a++;
            }
            else if (num < 0){
                b++;
            }
            else
                break;
        }

        System.out.println("正数的个数为：" + a);
        System.out.println("负数的个数为：" + b);
    }
}

嵌套循环

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=mn次。

练习

练习1：九九乘法表

public class TestJiuJiu {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++){ //一共9行
            for (int j = 1; j <= i; j++){ //每行有i个等式
                System.out.print(i + "*" + j + "=" + i*j + "\t");
            }
            System.out.println();
        }
    }
}

练习2：1—100之间的所有质数

public class TestPrimeNumber {
    public static void main(String[] args) {
        boolean flag = false;
        for (int i = 1; i <= 100; i++){  //实现100以内自然数的遍历
            for (int j = 2; j < i; j++){ //判断i是否为质数
                if (i % j == 0){
                    flag = true;
                }
            }
            if (flag == false){
                System.out.println(i);
            }
            flag = false;
        }
    }
}

优化：

if (i % j == 0){
    flag = true;
    break;
}

for (int j = 2; j <= Math.sqrt(i); j++){ //判断i是否为质数
    if (i % j == 0){
        flag = true;
        break;
    }
}

break continue

break
- 使用在switch-case中
- 使用在循环中，表示结束当前循环
continue
- 使用在循环结构中，表示结束当次循环
添加标签（break和continue都可以添加标签），标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句

label:for (int i = 1; i <= 5; i++){
    for (int j = 1; j <= 10; j++){
        if (j % 4 == 0){
            break label;
        }
        System.out.print(j);
    }
    System.out.println();
}

练习：1—100之间的所有质数

public class TestPrimeNumber2 {
    public static void main(String[] args) {
        l:for (int i = 1; i <= 100; i++){  //实现100以内自然数的遍历
            for (int j = 2; j < i; j++){ //判断i是否为质数
                if (i % j == 0){
                    continue l;
                }
            }
            System.out.println(i);
        }
    }
}

return

return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

面试题

写出结果。

class Demo
{
	public static void main(String[] args)
	{
		  int m=0,n=3;
		  if(m>0)
		      if(n>2)
			       System.out.println("A");	
	    else
		      System.out.println("B");
  }
}

//没有结果

switch是否能作用在byte上，是否能作用在long上，是否能作用在String上

答：switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long不能作用于swtich。JDK1.7新加入了String类型。

从键盘分别输入年、月、日，判断这一天是当年的第几天。

写出结果。

public class Demo{ 
	  public static void main(String []args){ 
		    int i = 0, j = 5; 
		    tp: for (;;){ 
			      i++; 
			      for(;;){
				        if(i > j--)
					          break tp; 
            }
        } 
		    System.out.println("i = " + i + ", j = "+ j);  //i=1,j=-1;
    } 
}

输出从1到100之间所有的整数;
输出从1到100之间所有的奇数;
输出从1到100之间所有不能被3整除的数;并输出这些整数的和

输入长和宽，输出长方形，如：输入4和3, 将输出如下图形
####
####
####
输入高度，输出直角三角形。如：输入4, 将输出如下图形
#
##
###
####
输入高度，输出倒直角三角形。如：输入4, 将输出如下图形
####
###
#

打印九九乘法表

输入两个正整数m和n，求其最大公约数和最小公倍数

int m = 12, n = 28;
//获取m和n的较大值
int max = (m > n)? m : n;
//获取m和n的较小值
int min = (m < n)? m : n;

//求m和n的最大公约数
for(int i = min;i >= 1;i--){
	if( m % i == 0 && n % i == 0){
		System.out.println("m和n的最大公约数是：" + i);
		break;
	}
}
//求m和n的最小公倍数
for(int i = max;i <= m * n;i++){
	if( i % m == 0 && i % n == 0){
		System.out.println("m和n的最小公倍数是：" + i);
		break;
	}
}

分别使用if-else if-else语句和switch-case语句,根据用于指定月份，打印该月份所属的季节。
//3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

已知学生成绩以100分为满分，共分5个等级：A,B,C,D,E。90～100为等级A，80～89为等级B，70～79为等级C，60～69为等级D，0～59为等级E。要求定义一个成绩变量，当成绩变化时，可直接知道该成绩对应的等级。例如：当成绩为100时，该学生的等级时A。

打印1~100之间 6的倍数的个数。
求出1～100之间，既是3又是7的倍数的自然数出现的次数？

求调和级数中从第多少项开始值大于10，调和级数的第n项形式为：1+1/2+1/3+…+1/n

3000米长的绳子，每天减一半。问多少天这个绳子会小于5米？不考虑小数。

public static void main(String[] args){
	int day = 0;
	for(int x=3000; x>=5; x/=2){
		day++;
	}
	System.out.println("day="+day);
	/*
	方法二：
	day = 0;
	for(int x=3000; x>=5; day++)
	{
		x = x/2;
	}
	System.out.println(day);
	*/
}

编写程序，判断给定的某个年份是否是闰年。
闰年的判断规则如下：

  **（1）若某个年份能被4整除但不能被100整除，则是闰年。**
  **（2）若某个年份能被400整除，则也是闰年。**

要求用户输入两个数a和b，如果a能被b整除或者a加b大于1000，则输出a；否则输出b。

一个数如果恰好等于它的因子之和，这个数就称为”完数”。（因子：除去这个数本身正的约数）
例如6=1＋2＋3，编程：找出1000以内的所有完数

public class WanShu {
	static int count;
	public static void main(String[] args) {
		int factor=0;
		for (int i = 1; i <= 1000; i++) {
			for (int j = 1; j < i; j++) {
				if(i%j==0)
					factor+=j;
			} 
			if(factor == i){
				System.out.println(i);
				count++;
			}
			factor=0;
		}
		System.out.println("1-1000之间的完数个数为："+count);
	}
}

写一个程序，找出4位数的所有吸血鬼的数字
例如：1260=2160
1827=2187

public class Test2 {
	public static void main(String[] args) {
		for (int num = 1001; num < 10000; num++) {
			math(num);
		}
	}
  public static void math(int num) {
    int[] temp1 = new int[2]; 
    int[] temp2 = new int[2]; 

    int a = num / 1000;
    int b = num / 100 % 10;
    int c = num / 10 % 10;
    int d = num % 10;
    int[] data = { a, b, c, d };
    for(int i = 0;i<data.length;i++){
      for(int j = 0;j < data.length;j++){
        if(i == j){
          continue;
        }
        temp1[0] = data[i];
        temp1[1] = data[j];
        for(int m = 0;m<data.length;m++){
          if(m != i && m != j){
            temp2[0] = data[m];
            for(int n = 0;n<data.length;n++){
              if( n != i && n != j && n != m){
                temp2[1] = data[n];
                multi(data,temp1,temp2);
              }
            }
          }
        }
      }
    }
  }
  public static int toInt(int[] temp){
    int m = 0;
    int[] temp1 = new int[temp.length];
    for(int i = 0;i < temp.length;i++){
      temp1[i] = temp[i]*(int)Math.pow(10, temp.length-1-i);
    }
    for(int i = 0;i < temp1.length;i++){
      m+=temp1[i];
    }
    return m;
  }
  public static void multi(int[] temp ,int[] temp1,int[] temp2){
    int i = toInt(temp1);
    int j = toInt(temp2);
    int k = toInt(temp);
    if(k == i*j){
      System.out.println(k + "=" + i + "*" + j);
    }
  }
}

输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如： 153 = 1 * 1 * 1 + 3 * 3 * 3 + 5 * 5 * 5

在JAVA中，如何跳出当前的多重嵌套循环?

答：用break；return 方法。

数组

概述

数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
数组属于引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

一维数组

声明

type var[] 或 type[] var

int a[]
int[] a1
double b[]
Mydate[] c //对象数组

注意：Java语言中声明数组时不能指定其长度(数组中元素的数)，例如：int a[5]; //非法

初始化

静态初始化

在定义数组的同时就为数组元素分配空间并赋值。

1 2	int a[] = new int[]{ 3, 9, 8}; int[] a = {3,9,8};

MyDate dates[] = {
   new MyDate(22, 7, 1964),
   new MyDate(1, 1, 2000),
   new MyDate(22, 12, 1964)
}

动态初始化

数组声明且为数组元素分配空间与赋值的操作分开进行。

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

MyDate dates[];
dates = new MyDate[3];
dates[0] = new MyDate(22, 7, 1964);
dates[1] = new MyDate(1, 1, 2000);
dates[2] = new MyDate(22, 12, 1964);

数组元素的默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：

public class Test {
     public static void main(String argv[]){
         int a[]= new int[5]; 
         System.out.println(a[3]);	//a[3]的默认值为0
     }
}

对于基本数据类型而言，默认初始化值各有不同
- byte、short、int、long：创建数组后，默认初始值为0
- float、double：创建数组后，默认初始值为0.0
- char：创建数组后，默认初始值为空格
- boolean：创建数组后，默认初始值为false
对于引用数据类型而言，默认初始化值为null（注意与0不同！)
- 例如：String

内存的解析

数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素
数组元素的引用方式：数组名[数组元素下标]
- 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i]
- 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —> n-1；如int a[ ]=new int[3];可引用的数组元素为a[0]、a[1]、a[2]
每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
- 数组一旦初始化，其长度是不可变的

练习

练习1：

定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。定义类Array1，在Array1的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。练习目的：检验基本数据类型数组创建时的自动赋值。
给对象d的成员变量t赋值为{true,true,true}，并输出t的三个元素值。

public class TestPritimive {
    public static void main(String[] args) {
        Pritimive d = new Pritimive();
        d.t[0] = true;
        d.t[1] = true;
        d.t[2] = true;
        for (int i = 0; i < d.t.length; i++){
            System.out.println(d.t[i]);
        }
    }
}
class Pritimive{
    boolean[] t = new boolean[3];
}

练习2：从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余等级为’D’

提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

import java.util.Scanner;

public class TestStudentScore {
    public static void main(String[] args) {
        // 1、创建Sacnner对象，并从键盘获取学生的个数
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入学生的个数：");
        int count = scanner.nextInt(); // count记录学生的个数
        // 2、根据输入的学生个数n，创建一个长度为n的int型数组
        int[] scores = new int[count];
        int maxScore = 0;
        // 3、依次从键盘获取n个学生的成绩，并赋值给相应元素，并获取n个学生中的最高分
        System.out.println("请输入" + count + "个学生的成绩：");
        for (int i = 0; i < scores.length; i++){
            int score = scanner.nextInt(); //依次从键盘获取学生成绩
            scores[i] = score;
            if (scores[i] > maxScore){
                maxScore = scores[i];
            }
        }
        // 4、遍历学生成绩数组，并根据学生成绩与最高分的差值，赋予相应的等级并输出
        System.out.println("最高分是：" + maxScore);
        for (int i = 0; i < scores.length; i++){
            char level;
            if (scores[i] >= maxScore-10){
                level = 'A';
            }
            else if (scores[i] >= maxScore-20){
                level = 'B';
            }
            else if (scores[i] >= maxScore-30){
                level = 'C';
            }else {
                level = 'D';
            }
            System.out.println("student" + i + " score is " + scores[i] + "，Grade is " + level);
        }
    }
}

多维数组

二维数组：数组中的数组

初始化

动态初始化

int[][] arr = new int[3][2];
- 定义了名称为arr的二维数组
- 二维数组中有3个一维数组
- 每一个一维数组中有2个元素
- 一维数组的名称分别为arr[0], arr[1], arr[2]
- 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
int[][] arr = new int[3][];
- 二维数组中有3个一维数组
- 每个一维数组都是默认初始化值null (注意：区别于格式1）
- 可以对这个三个一维数组分别进行初始化，arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];

注：int[][]arr = new int[][3]; //非法

静态初始化

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
- 定义一个名称为arr的二维数组，二维数组中有三个一维数组
- 每一个一维数组中具体元素也都已初始化
- 第一个一维数组arr[0] = {3,8,2}
- 第二个一维数组arr[1] = {2,7}
- 第三个一维数组arr[2] = {9,0,1,6}
- 第三个一维数组的长度表示方式：arr[2].length

注：注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。Java中多维数组不必都是规则矩阵形式。

内存结构

数组常见异常

数组下标越界的异常：java.lang.ArrayIndexOutOfBoundsException

1
2
3

int[] i = new int[10];
i[0] = 90;
i[10] = 99;

空指针的异常：NullPointerException

1
2
3

boolean[] b = new boolean[3];
b = null;
System.out.println(b[0]);

1 2	String[] str = new String[4]; System.out.println(str[3].toString());

1 2	int[][] j = new int[3][]; j[2][0] = 12;

练习

练习1：获取arr数组中所有元素的和。使用for的嵌套循环即可。

public class TestGetSum {
    public static void main(String[] args) {
        int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
        int sum = 0;
        for (int i = 0; i < arr.length; i++){
            for (int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j] + "\t");
                sum += arr[i][j];
            }
            System.out.println();
        }
        System.out.println("该二维数组总和为：" + sum);
    }
}

练习2：声明：int[] x,y[]; 以下选项允许通过编译的是：

a ) x[0] = y; //no

b) y[0] = x; //yes

c) y[0][0] = x; //no

d) x[0][0] = y; //no

e) y[0][0] = x[0]; //yes

f) x = y; //no

一维数组：int[] x 或者int x[]

二维数组：int[][] y 或者 int[] y[] 或者 int y[][]

练习3：使用二维数组打印一个10行杨辉三角

【提示】

第一行有 1 个元素, 第 n 行有 n 个元素
每一行的第一个元素和最后一个元素都是 1
从第三行开始, 对于非第一个元素和最后一个元素的元素. yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];

public class TestYangHui {
    public static void main(String[] args) {
        int[][] yangHui = new int[10][];
        // 1、初始化二维数组
        for (int i = 0; i < yangHui.length; i++){
            yangHui[i] = new int[i+1];
        }
        //2、显式的为二维数组的每个元素赋值
        for (int i = 0; i < yangHui.length; i++){
            for (int j = 0; j < yangHui[i].length; j++){
                yangHui[i][0] = yangHui[i][i] = 1;
                if (i > 1 && j > 0 && j < i){
                    yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
                }
            }
        }
        //3、遍历数组
        for (int i = 0; i < yangHui.length; i++){
            for (int j = 0; j < yangHui[i].length; j++){
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

常见算法

最大最小值平均值总和

练习：定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，平均值，和值，并输出。

//求数组元素的最大值、最小值、平均数、总和等
public class Algorithm1 {
    public static void main(String[] args) {
        int[] arr = new int[]{12,43,9,0,-65,-99,100,9};

        //最大值
        int max = arr[0];
        for (int i = 0; i < arr.length; i++){
            if (max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("数组的最大值为：" + max);

        //最小值
        int min = arr[0];
        for (int i = 0; i < arr.length; i++){
            if (min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("数组的最小值为：" + min);

        //总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++){
            sum += arr[i];
        }
        System.out.println("数组的总和为：" + sum);

        //平均数
        int avg = sum / arr.length;
        System.out.println("数组的平均数为：" + avg);
    }
}

复制反转

练习：使用简单数组

(1) 创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。

(2) 使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。

(3) 显示array1的内容。

(4) 赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。

public class TestArray {
     public static void main(String[] args) {
         int[] array1,array2;
         array1 = new int[]{2,3,5,7,11,13,17,19};
         for (int i = 0; i < array1.length; i++){
             System.out.print(array1[i] + "\t");
         }
         System.out.println();
         array2 = array1;
         for (int j = 0; j < array2.length; j++){
             if (j % 2 == 0){
                 array2[j] = j;
             }
         }
         for (int i = 0; i < array1.length; i++){
             System.out.print(array1[i] + "\t");
         }
     }
}

小结：

将array1的地址传给array2了，修改array2，array1也会变

练习：数组的复制

//数组的复制
public class Algorithm2 {
    public static void main(String[] args) {
        int[] arr = new int[]{12,43,9,0,-65,-99,100,9};
        int[] arr2 = new int[arr.length];
        for (int i = 0; i < arr2.length; i++){
            arr2[i] = arr[i];
        }
        for (int i = 0; i < arr2.length; i++){
            System.out.print(arr2[i] + "\t");
        }
    }
}

练习：数组的反转

//数组的反转
public class Algorithm3 {
    public static void main(String[] args) {
        int[] arr = new int[]{12,43,9,0,-65,-99,100,9};
        //第一种方法
        for (int i = 0; i < arr.length / 2; i++){
            int temp  = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
        //第二种方法
        for (int x = 0, y = arr.length - 1; x < y; x++, y--){
            int temp = arr[x];
            arr[x] = arr[y];
            arr[y] = temp;
        }
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
    }
}

排序

插入排序

直接插入排序
折半插入排序
Shell排序

交换排序

冒泡排序
快速排序（或分区交换排序）

选择排序

简单选择排序
堆排序

归并排序

基数排序

排序方法的选择

若n较小(如n≤50)，可采用直接插入或直接选择排序。当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。

数组操作

数组排序

java.util.Arrays类的sort()方法提供了数组元素排序功能：

import java.util.*;

public class Sort {
    public static void main(String[] args) {
        int [] number = {5,900,1,5,77,30,64,700};
        Arrays.sort(number); 
        for(int i = 0; i < number.length; i++) {
          System.out.println(number[i]);
        }            
    }
}

工具类Arrays

java.util.Arrays类包含了用来操作数组（比如排序和搜索）的各种方法。Arrays拥有一组static方法：

equals()：比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。
fill()：将值填入array中。
sort()：用来对array进行排序。
binarySearch()：在排好序的array中寻找元素。
System.arraycopy()：array的复制。

面试题

java能动态分配数组吗？

答：可以。int i = 12;int[] myInt = new int[i];

我怎么知道数组的长度？

答：.length属性获取

数组有没有length()这个方法? String有没有length()这个方法?

答：数组没有length()这个方法，有length的属性。String有length()这个方法

Java中的任何数据类型都可以使用System.out.println方法显示。
对基本数据类型而言，输出的往往是变量的值；
对于像数组这一类复杂的数据类型，会如何呢？

String[] stringArray = new String[3]; // 各元素的值默认为null
for (int i = 0; i < stringArray.length; i++) { // 对各元素进行初始化，但没有赋值。
	stringArray[i] = new String();
	System.out.println(stringArray[i]);
}

空（有别于null）

操作二维数组不应使用常数来控制维数。具体方法是array.length表示行数，array[row].length来表示row行的列数。这样当数组行数和列数不相等时，代码可以自动调整为正确的值。

下面数组定义正确的有（ B D ）
A.String strs[] = { ‘a’ ‘b’ ‘c’};
B.String[] strs = {“a”, “b”, “c”};
C.String[] strs = new String{“a” ”b” ”c”};
D.String strs[] = new String[]{“a”, “b”, “c”};
E.String[] strs = new String[3]{“a”, “b”, “c”};

写出结果。

class Demo{
	public static void main(String[] args){
		String foo="blue"; 
		boolean[] bar=new boolean[2]; 
		if(bar[0]){ 
      			foo="green"; 
   		} 
		System.out.println(foo);
	}
}

[输出]：blue

下面哪个数组定义是错误的。并对错误的答案加上单行注释，写出错误的原因。
A：float[]=new float[3]; //
B：float f2[]=new float[]; //
C：float[] f1=new float[3]; //
D：boolean[] b={“true”,”false”,”true”}; //
E：double f4[]={1,3,5}; //
F：int f5[]=new int[3]{2,3,4}; //

G, float f4[]={1.2F,3.0,5.4};//

数组a[n]，用java代码将数组元素顺序颠倒

任意一个人输入年龄，就可以判断出他是哪个年龄段的人？
0-9 儿童
10-19 少年
20-29 青少年
30-39 青年
40-49 壮年
50-59 中年
60-69 中老年
70-79 老年
80-89 老老年
90-99 老老老年

// 1.switch
	int age = 34;
	switch(age/10){
		case 0:		....0-9....
		case 1:   ....10-19....
		case 2:   .....
}

// 2.if...else.....
	if(age>=0 && age<10){
		.....
	}else if(age>=10 && age< 20){
		....
	}else......
    
// 3.数据结构的思想
	int age = 22;
	String[] arr = {"儿童","少年","青少年","青年","壮年","中年","","","",""};
	int idx = age/10;
	System.out.println(arr[idx])

关键字

关键字

保留字

标识符

变量

基本概念

程序的执行过程

变量的分类

按数据类型

整数类型

浮点类型

字符类型

补充

ASCII码

Unicode编码

UTF-8

布尔类型

按声明的位置

类型转换

自动类型转换

强制类型转换

补充：String类

练习1

练习2

进制

表示方式

原码 反码 补码

进制转换

十进制 二进制

二进制 八进制 十六进制

运算符

算术运算符

赋值运算符

比较运算符

逻辑运算符

位运算符

左移 右移

无符号右移

与/或

异或

反码

细节

三元运算符

运算符的优先级

面试题

程序流程控制

分支结构

if-else

练习

switch

switch和if对比

练习

循环结构

for循环

练习

while循环

do-while循环

练习

嵌套循环

练习

break continue

return

面试题

数组

概述

一维数组

声明

初始化

静态初始化

动态初始化

数组元素的默认初始化

内存的解析

数组元素的引用

练习

多维数组

初始化

动态初始化

静态初始化

内存结构

数组常见异常

原码反码补码

十进制二进制

二进制八进制十六进制

左移右移

最大最小值平均值总和

复制反转