字符串

1. String:对象是jdk提供的 字符串只能用双引号

2. Sting：没有范围大小（要学会拼接字符串

3. 引用数据类型：除了基本数据类型，都是引用数据类型

包

1. 包实质上就是文件夹：分门别类

2. 包的命名规则：

   1. 尽量使用全小写，

   2. 尽量用字母，

   3. 包名中尽量不出现_ $和数字

   4. 一般情况下使用站点名逆序：www.baidu.com

      1. com.baidu.搜索包

      2. com.baidu.架构名

Scanner：获取从键盘输入的值

•  包路径：java.util.Scanner
• 通过Sanner对象实现接收用户键入

  //需要将Scanner类导入
  import java.util.Scanner;
  
  public class Test {
  	public static void main(String[] args){
  		
  		//创建Scanner的对象s
  		Sanner s = new Scanner(System.in);
  		//接收int类型
  		int i = s.nextInt();
  		//接收String类型
  		String s = s.next();
  	}
  }
  

流程控制

if

1. 如果情况比较多，条件判断比较复杂，最后一种情况不建议直接写else

stitch case

1. 练习题：小明参加成绩管理系统 从键盘输入成绩，如果成绩是60分合格，如果成绩85分奖励ipad，如果成绩100分奖励十三香，其他情况没有奖励

           double score = new Scanner(System.in).nextDouble();
           System.out.println("请输入成绩：");
           switch ((int) score){
   
               case 60:
                   System.out.println("奖励你个粑粑");
                   break;
               case 85:
                   System.out.println("奖励你个IPAD");
                   break;
               case 100:
                   System.out.println("奖励你一个IPhone");
                   break;
               default:
                   if (score > 100 || score < 0){
                       System.out.println("成绩有误");
                   }
                   else {
                   System.out.println("奖励你一个大嘴巴子");
               }
           }
   

2. switch 只能判断byte short int 浮点型都不行 字符型可以，boolean不可以，字符串可以（在jdk1.7以后的版本），枚举可以（jdk5以后的版本）；

数组

• 数组的声明与初始化

动态初始化：
        int[] intArr = new int[10]; ----> 声明一个长度为10的数组，初始化的值给定为int类型的默认值

静态初始化：
        int[] intArr = new int[]{1,2,3,4,5} ;—> 声明一个长度为5的数组，并给定数组元素的值。此处可以简写为 int[] intArr = {1,2,3,4,5};

对于数组初始化默认值

•  在动态初始化中，数组元素的默认值就是数组元素类型的默认值
•  在静态初始化中，数组元素也有默认值，只不过系统自动马上将默认值替换成大括号里的具体数值

在Java中各种类型的默认值

数据类型    默认值
整数型    0
浮点型    0.0
字符型    ‘u0000’
布尔类型    false
引用数据类型    null

---

数组这种结构有什么其优缺点：

• 优点

检索元素效率极高。——原因：在一个数组中数组元素的内存地址是连续的；知道数组的地址值，知道数量数组元素所占字节数(因为在同一个数组中数组元素的类型必须相同，所以在同一个数组中数组元素所占字节数都是相同的)，知道数组元素的下标，我们可以通过一个数学表达式计算出某一个数组元素下标的地址值，所以检索效率极高
向数组末尾添加元素效率极高。——原因：向数组末尾添加元素，并不涉及到整体元素的位移操作，所以效率高

• 缺点

数组不能存储大容量数据。——原因：很难在堆内存中找到一块很大且连续的空间
数组删除元素效率很低。——原因：为了保证数组地址值式连续的这种特点，删除元素会涉及到整体元素向前或向后位移操作，所以效率很低
数组扩容
可以以使用System.arraycopy()对数组扩容
数组扩容效率极低，尽量减少数组的扩容次数
数组内存分析

1. int [ ] a1 = {1，2，3，4，5};//可以用字面量直接赋值，尽量不用
2. int a2 [ ] = { };//也可以直接赋值
3. int [ ] a2 = new int [5];//声明长度
4. int [ ] a3 = new int [ ] {1,2,3,4};
数组一旦声明要指定长度；

注意：

[ ] 只能出现在 = 左边除了 int [ ] a2 = new int [5];

访问数组元素通过下标（索引），下标从0开始

数据类型的初始值：

byte,short,int,long:0

float.double : 0.0

char :（ u0000）空白：什么都不显示

boolean ：false

string ：null

循环： 选择结构 if选择结构

1. if()

2. if()…else

3. if()…else if()…

4. if() else if()…else

 1. 对于2，4这两个选择结构，肯定会有分支会被执行到。

 2. 对于1，3这两个选择结构，则无法肯定会不会有分支执行到。

 3. 对于"()"中的表达式，要求运算结果是布尔值

switch选择结构 switch结构

public static void main(String[] args){
	int i1 = 10;
	// i1在此处可被称为受测变量
	switch(i1) {
		case 5:
			System.out.print(i1 + "和5匹配");
			break;
		case 10:
			System.out.print(i1 + "和10匹配");
			break;
		default:
			System.out.print(i1 + "和5、10不匹配");
			break;
	}
}

switch重点
  1. break的穿透性     对于switch匹配到的分支，如果没写break，程序会继续往下一个分支执行   2. switch支持的数据类型
    * int类型 (byte、short、char)     * String类型     * 枚举类型

在java5之后，switch支持枚举类型，以及根据拆箱机制可以使用包装类:(Integer/Byte/Short/Character)
在java7之后，switch支持String类型

     3. case合并

public static void main(String[] args){
	int i = 10;
	switch(i1) {
		case 10: case 20: case 30:
			System.out.println("i的值是10，20，30中的一个");
			break;
		default:
			System.out.println("i的值是其他值");

	}
}

for循环

初始化条件 ：任意类型，但大部分用int

双层for循环

执行流程：

• i=0.外层for循环启动
• 执行外层for循环的循环体
• 走里层for循环（循环体）
• 里层for循环走完j 打印
• 里层for循环走完（循环体）
• i= 0 外循环执行完毕，进行下次i=1执行

课堂实例：模拟计算器

1.for死循环：

public static void main(String[] args) {

//        从键盘输入两个数字和一个符号
//        加减乘除
//        打印输出计算结果
//        注意：除数不能为零，符号输入不对怎么办
//        计算器能不能一直计算下去
            Scanner sc = new Scanner(System.in);
            c:for(int i = 0;;i++) {
                System.out.println("请输入第一个数：");
                double sum1 = sc.nextDouble();
                a:while (true){
                    System.out.println("请输入第二个数：");
                    double sum2 = sc.nextDouble();
                    System.out.println("请输入计算符：");
                    String fu = sc.next();
                    switch (fu) {
                        case "+":
                            System.out.println(sum1 + fu + sum2 + "=" + (sum1 + sum2));
                            break;
                        case "-":
                            System.out.println(sum1 + fu + sum2 + "=" + (sum1 - sum2));
                            break;
                        case "*":
                            System.out.println(sum1 + fu + sum2 + "=" + (sum1 * sum2));
                            break;
                        case "/":
                            if (sum2 != 0) {
                                System.out.println(sum1 + fu + sum2 + "=" + (sum1 / sum2));
                                break;
                            } else {
                                System.out.println("除数不能为0，请重新输入");
                                continue a;
                            }
                        default:
                            System.out.println("无效运算符，请重新输入");
                            continue;
                    }
                    b:while (true){
                        System.out.println("请选择是否继续运算：1:继续计算，0:停止运算）");
                        int sum = sc.nextInt();
                        if (sum == 1) {
                            continue;
                        }
                        else if (sum==0){
                            System.out.println("感谢使用！");
//                            break c;
//                            终止程序执行的啊方式
//                            0：安全退出：提示
//                            -1：强制退出
                            System.exit(-1);
                        }
                        else{
                            System.out.println("无效代码，请重新输入");
                            continue  b;
                        }
                    }
                }
            }
    }

while：死循环

iimport java.util.Scanner;

public class Test6 {
		
	
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);

		int flag = 1;
		while(flag == 1) {
			System.out.print("请输入第一个数：");
			int first = s.nextInt();
			System.out.print("请输入第二个数：");
			int second = s.nextInt();
			System.out.print("请输入运算符号(+,-,*,/)：");
			String opera = s.next();

			switch(opera) {				
				case "+":
					System.out.println("计算结果为："+ first +"+"+ second +"="+ (first+second));
					break;
				case "-":
					System.out.println("计算结果为："+ first +"-"+ second +"="+ (first-second));
					break;
				case "*":
					System.out.println("计算结果为："+ first +"*"+ second +"="+ (first*second));
		
					break;
				case "/":
					while(second == 0) {
						System.out.print("除数不能为0，请重新输入第二个数字：");
						second = s.nextInt();
						
					}
					System.out.println("计算结果为："+ first +"/"+ second +"="+ (first/second));	
					break;
		
				default:
					System.out.println("不存在该运算符");

					break;
			}
			
			System.out.print("是否继续计算：1、是 2、否：");
			flag=s.nextInt();
			while(flag != 1  && flag !=2) {
						System.out.print("输入错误请重新输入");
						flag=s.nextInt();
			}
			System.out.print(flag == 2 ? "计算器已经终止，谢谢您的使用n" : "");
		}

	}
}

do…while循环结构 foreach(增强for)

可以把数组中的元素通过镜像给变量接收，我们操作的不是原始数据，我们操作的是镜像数据，foreach的操作更加安全，不影响原始数据。foreach是Java5新特性

控制循环的语句
  * break——> 中断循环(最近的)
  * continue——>结束本次循环(最近的)

对于break，continue都可以指定循环，只需要在给循环加一个标签，然后使用break/continue 标签名 即可

 

	public static void main(String[] args){
		for1:for(int i=0; i<5; i++) {
			for(int j=0; j<5; j++) {
				if(i == 1) {
					break for1;
				}
				System.out.print("*");
			}
		}
	}

其他：

break和continue：只能控制离他们最近的循环

循环的标签：goto语法，goto功能

foreach 增强for循环 遍历数组 JDK5以后新增的，枚举，

终止程序执行的方式除了（break）还有   System.exit()

BeBug的使用

暑期编程PK赛 得CSDN机械键盘等精美礼品！