Java基础 (9.28)

JDK，JRE

java执行流程和编译

java开发注意事项

项目流程开发

Java代码规范

第一个程序

//1、Hello{} 表示一个类的开始和结束    
//2、public static void main(String[] args){} 表示一个主方法，程序的入口
public class Hello{
    //编写一个main方法
     public static void main(String[] args) {
        System.out.println("微咲欢迎来到java");
    }
}

Java开发注意事项和细节说明

    一个源文件中最多只能有一个public类。其他类的个数不限。
    如果源文件包含一个public类，则文件名必须按该类名命名！
    一个源文件中最多只能有一个public类，其他类的个数不限，也可以将main方法写在非public类中，然后指定运行非public类，这样入口方法就是非public的main方法

java转义字符

\t:制表符

\n:换行符

\ _ \’: \ _ ‘

\r:回车

java转义字符代码实现

//演示转义字符的使用
public class ChangeChar{
    //编写一个main方法
    public static void main(String[] args) {
        //  \t:制表符
        System.out.println("我\t是\t你\t爹");
        //  \n:换行符
        System.out.println("\n我\t是\t你\t爹");
        // \\ \*  \':    \  *  '
        //   \r:回车
        System.out.println("\r你好");
    }
}

Java容易犯的错误

注释（comment）

注释代码实现

/**
 * 文档注释
 * @author 微咲
 * @version 1.0
 * */
public class Commen{
    public static void main(String[] args) {
        //这是单行注释  ( ctrl + / )
        /*
        多行注释多行注释多行注释多行注释多行注释
        多行注释多行注释多行注释多行注释多行注释
        多行注释多行注释多行注释多行注释多行注释
        多行注释多行注释多行注释多行注释多行注释
        */
    }
}

注释格式

_单行注释： //注释文字_5

多行注释：/注释文字/

文档注释：/**

                *
                */

文档注释

通过javadoc 可以生成一套一网页文件形式提现的改程序的说明文档。

使用细节

被注释的文字，不会被JVM（Java虚拟机）解释执行

多行注释里不允许有多行注释嵌套

Java代码规范部分

源文件使用utf-8

DOS命令（了解）

相对路径和绝对路径

相对路径

：从当前目录开始定位，形成的一个路径。

例如：Hello.java

绝对路径

：从顶级目录（c、d..盘）开始定位，形成的一个路径。

例如：C:\Users\46124\Desktop\javaCodeSource\JavaOneday\Hello.java

DOS介绍

Dos：Disk Operatring System 磁盘操作系统

常用的dos命令

help （）：可以查看如何使用

• dir：查看当前目录所有文件
• cd：切换到其他盘下

例如：切换到c盘： cd/D c:

• cd ..：切换到上一级
• cd\：切换到根目录表
• tree：查看指定目录下所有的子级目录
• cls：清屏
• exit：退出DOS
• md：创建目录
• rd：删除目录
• copy：复制文件
• del：删除文件
• echo：输入内容到文件
• type：
• move：剪切

变量及类型转换

public class Var{
    public static void main(String[] args) {
        int age=19;
        double length=175.5;
        char gender='男';
        String name="微咲";
        System.out.println("我叫，是个生，今天岁了，身高是cm");
        //long int
        //int lint=99L;  //报错 无法将long int->int
        //long lInt=99L;  //对的
        //float
        //float f1=1.1;  //报错 无法将double->float
        //float f2=1.1F;  //ok
        //double f3=1.1f;  //ok
        //0.123  可以将0省略
        //double d1=.123;
        //科学计数法 5.12e2 [5.12*10 二次方]
        System.out.println(5.12e2);//512.0
        System.out.println(5.12E-2);//0.0512
        double num1 = 2.7;
        double num2 = 8.1 / 3;
        if (num1-num2<0.0001) {
            System.out.println("这基本就是相等！");
        }
        System.out.print(Math.abs(num1-num2));
        //char  
        char c1='c';
        char c2='\t';
        char c3='韦';
        char c4=97;   // 输出的是对应ASCII码对应的字符
        char c5='a';
        System.out.println((int)c5);
        char c6='韦';
        System.out.println((int)c6);
        System.out.println('a'+3);
        //boolean
        boolean isPass = true;
        if (isPass == true) {
            System.out.println("恭喜");
        }
        else {
            System.out.println("不恭喜");
        }
    }
}

• 变量是程序的基本组成单位
• 变量三要素：类型+名称+值

变量使用注意事项

+号的使用

1. 当两边都是数字型时，做加法运算
2. 当左右两边有一方为字符串时，则做拼接运算

数据类型

整数类型

Java的整数类型就是用来存放数值的。

类型|占用存储空间|范围

byte [字节]|1字节|-128~127（二进制） (8bit)

short [短整型]|2字节|-(2的15次方)~2的15次方-1

int [整型]|4字节|-(2的31次方)~2的31次方-1

long [长整型]|8字节|-(2的63次方)~2的63次方-1

long类型声明：long lNumber=9999L;

bit：计算机中最小存储单位。

byte：计算机中基本存储单元。

浮点类型

Java的浮点类型可以表示一个小数。

• 浮点数在机器中存放形式：浮点数=符号位+指数位+尾数位
• 尾数部分可能丢失，造成精度损失（小数都是近似值）所以通常使用double类型

float声明： flaot f1=1.1f;

                  double f2=1.1f;

浮点数使用陷阱：2.7 和 8.1 / 3比较

double num1 = 2.7;

double num2 = 8.1 / 3;

num2 = 2.66666667;

———>当我们对运算结果是小数进行相等判断时，要小心

字符类型

字符类型可以表示单个字符，字符类型是char，char是两个字节（可以存放汉字），多个字符我们用字符串String。

char c4=97; // 输出的是对应Unicode ASCII 码对应的字符

字符常量使用细节

1. 字符常量是用单引号（’’）括起来的单个字符
2. Java中还允许使用转义字符’\’来将其后字符转变成特殊字符型常量
3. 在Java中，char的本质是一个整数，在输出时，是Unicode码对应的字符
4. char类型是可以进行运算的
   char c5=’a’;
   System.out.println((int)a);

字符类型本质

1.字符型存储到计算机中，需要将字符对应的码值找出来。比如 ‘a’

存储：'a' == > 码值97 == > 二进制(1100001) == >存储
读取：二进制(1100001) == > 97== > 'a'  == > 显示

2.字符和码值的对应关系是通过字符编码表决定的。

• ASCII（ASCII编码表，一个字节表示，共128个字符，实际上一个字节可以表示256个字符，但只用了128个）
• Unicode（Unicode编码表，固定大小的编码，使用两个字节表示字符，字母和汉字统一都是占用两个字节，这样浪费空间）
• utf-8（大小可变的编码，字母使用1个字节，汉字使用3个字节）
  （互联网上使用最广的）
• GBK（可以表示汉字，范围广，字母使用1个字节，汉字2个字节）
• GBK2312（可以表示汉字，GB2312<GBK）
• Big5码（繁体中文，台湾，香港）
  Unicode兼容ASCII码

布尔类型

boolean：不可以用0或非0的整数替代false和true，这点和C不同。

基本数据类型转换

• 自动类型转换：当Java程序在进行赋值或者运算时，精度小的类型自动转换成精度大的数据类型，这个就是自动类型转换。
• 强制类型转换：自动转换的逆过程，将容量大的数据类型转换成容量小的数据类型，使用时要加上 强制转换符（），但可能会造成精度降低or溢出，需注意。
• 数据类型按精度（容量）大小排序为：
  char -> int -> long -> float -> double
  byte -> short -> int -> long -> float -> double

自动类型转换注意和细节

1. 有多种类型的数据混合运算时，系统首先将所有数据转换成容量最大的那种数据类型，然后在进行计算
   int n1 = 10; float d1 = n1 + 1.1; //错误
   float d1 = n1 + 1.1L; //OK
2. (byte,short)和char之间不会相互自动转换
3. byte,short,char,他们三者可以计算，在计算 byte b1 = 1;
   short s1 = 1;
   short s2 = b1 + s1;//错误，b1 + s1 =>int
   byte b2 = 1;
   byte b3 = b1 + b2;//错误b1 + b2=>int
   
4. boolean不参与类型转换
5. 自动提升原则：表达式结果的类型自动提升为，操作数中最大的类型
   double = int + float + short + byte +long;
   

强制类型转换细节说明

1. 当进行数据从把精度大的 => 精度小的，就需要强制转换
2. 强转符号就近操作，可用小括号提高优先级
3. char可以保存int常量值，但不能保存int变量值，需强转
4. byte和short，char类型在进行运算时，当作int类型处理

基本数据类型和String类型的转换

• 基本类型转String类型：将该基本类型的值+””即可
  int n1 = 1; String s1 = 1 + “”;
• String类型转基本数据类型：通过基本类型的包装类调用parseXX方法。
  int n2 = Integer.parseInt(“123”);
  double n3 = Double.parseDouble(“123.123”);

获得字符串中的字符：

System.out.println(s1.charAt(0));

基本数据类型和String类型的转换注意事项

1. 在将 String 类型转成 基本数据类型时， ，比如 我们可以把 “123” , 转成一 个整数，但是不能把 “hello” 转成一个整数
2. 如果格式不正确，就会抛出异常，程序就会终止， 这个问题在异常处理章节中，会处理

Java API

Java 8 API 中文版

Java类的组织形式：

JDK8->众包->每个包下有：接口，类（…），异常

类：->字段…+构造器（构造方法）+成员方法（方法）

运算符

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

1. 算术运算符
2. 关系运算符 [比较运算符]
3. 赋值运算符
4. 逻辑运算符
5. 三元运算符
6. 位运算符 [需要二进制基础]

算术运算符

加减乘除模

+ - * / % ：

% 取模，取余：在 % 的本质 看一个公式!!!! ：a % b = a - a / b * b

自加自减运算符

++ ：i++ => i = i + 1;

作为表达式使用
前++：++i 先自增后赋值
后++：i++先赋值后自增

 int i = 1;//i->1
 i = i++; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp;
 System.out.println(i); // 1
 int i=1;
 i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
 System.out.println(i); //2

关系运算符 [比较运算符]

1. 关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false
2. 关系表达式 经常用在 if 结构的条件中或循环结构的条件中

instanceof：检查是否是类的对象
细节说明

逻辑运算符

介绍：用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。

逻辑运算符一览：

1. 短路与 && ， 短路或 ||，取反 !
2. 逻辑与 &，逻辑或 |，^ 逻辑异或

说明逻辑运算规则

&&和&基本规则

&& 和 & 使用区别

&& 和 & 使用区别

1. &&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
2. & 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低

短路或 || 与逻辑或 |

||和 | 基本规则、|| 和 | 使用区别

同上&& 与 &

! 非（取反）

! 非（取反） !条件 如果条件本身成立，结果为 false，否则为 true

逻辑异或 ^

a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

赋值运算符

基本赋值运算符 = int a = 10;

复合赋值运算符

+= ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理

a += b; [等价 a = a + b; ]

a -= b; [等价 a = a - b; ]

三元运算符

基本语法

基本语法 ：条件表达式 ? 表达式 1: 表达式 2;

运算规则：

1. 如果条件表达式为 true，运算后的结果是表达式 1；
2. 如果条件表达式为 false，运算后的结果是表达式 2；

使用细节

使用细节：

1. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
2. 三元运算符可以转成 if—else 语句

//使用一条语句实现求三个数之间的最大值
int max = (n1 > n2 ? n1 : n2) > n3 ?
(n1 > n2 ? n1 : n2) : n3;
System.out.println("最大数=" + max);

运算符优先级

运算符优先级：（由高到低）

1. 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
2. 只有单目运算符、赋值运算符是从右向左运算的。
3. 一览表, 不要背，使用多了，就熟悉了.

标识符、关键字、保留字

标识符的命名规则

规则：必须遵守，不然报错。

标识符的命名规范

规范：命名更加专业。

1. 包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
2. 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰] 比如： TankShotGame
3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小 驼峰， 简称 驼峰法] 比如： tankShotGame
4. 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ 比如 ：定义一个所得税率 TAX_RATE
5. 后面我们学习到 类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.

关键字

关键字的定义和特点

定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：关键字中所有字母都为小写

保留字

介绍

Java 保留字：

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

键盘输入语句

介绍

    在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。需要一个 扫描器(对象), 就是 **Scanner**

步骤

步骤 ：

1. 导入该类的所在包, java.util.*
2. 创建该类对象（声明变量）
3. 调用里面的功能

import java.util.Scanner; //表示java.util下的Scanner类导入
public class Input{
    public static void main(String[] args) {
        //演示接受用户的输入
        //步骤：
        //Sacnner类：简单文本扫描器，在java.util包内
        //1.引入Scanner类所在的包
        //2.创建Scanner 对象，new 创建一个对象
        Scanner mySacnner = new Scanner(System.in);
        //3.接受用户的输入,使用相关的方法
        System.out.println("请输入名字：");
        String name = mySacnner.next();//接受用户输入
        System.out.println("请输入年龄：");
        int age = mySacnner.nextInt();
        System.out.println("请输入薪水：");
        double salay = mySacnner.nextDouble();
        System.out.println("name="+name+"age="+age+"salay="+salay);
    }
}

进制

进制介绍

对于整数，有四种表示方式：

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

进制的转换

二进制转换成十进制

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和。

八进制转换成十进制

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和。

十六进制转换成十进制

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后求和。

十进制转换成二进制

规则：将该数不断除以2，直到商为0位置，然后将每步得到的余数倒过来，就是对于的二进制。

十进制转换成八进制

规则：将该数不断除以8，直到商为0位置，然后将每步得到的余数倒过来，就是对于的八进制。

十进制转换成十六进制

规则：将该数不断除以16，直到商为0位置，然后将每步得到的余数倒过来，就是对于的十六进制。

二进制转换成八进制

规则：从低位开始，将二进制数每三位一组，转成对应的八进制数即可。

二进制转换成十六进制

规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。

八进制转换成二进制

规则：将八进制每一位数，转成对应的一个3位的二进制数即可。

十六进制转换成二进制

规则：将十六进制每一位数，转成对应的一个4位的二进制数即可。

原码、反码、补码

原码、反码、补码

1. 二进制的最高位是符号位：0表示正数，1表示负数
2. 正数的原码、反码、补码都一样
3. 负数的反码=它的原码符号位不变，其它位取反
4. 负数的补码=它的反码+1，负数的反码=负数的补码-1
5. 0的反码、补码都是0
6. java没有无符号数，换言之，java中的数都是有符号的
7. 在计算机运算的时候，都是以补码的方式来运算的
8. 当我们看运算结果的时候，要看他的原码

127+1= - 128

位运算符

java 中有 7 个位运算(&、|、 ^ 、~、>>、<<和 >>>)

算术运算符本质：
x>>y x/2^y
x<<y x*2^y

public class BitOperator{
    public static void main(String[] args) {
        //推导过程：
        //1、首先要获得2、3的补码
        //2、2的原码：00000000 00000000 00000000 00000010
        //  3的原码：00000000 00000000 00000000 00000011
        //3、2的补码：00000000 00000000 00000000 00000010
        //  3的补码：00000000 00000000 00000000 00000011
        //4、按位&
        //  00000000 00000000 00000000 00000010
        //  00000000 00000000 00000000 00000011
        //  00000000 00000000 00000000 00000010  运算后的补码
        //  将运算后的补码 -> 原码 2
        System.out.println(2&3); //2
        //推导过程：
        //1、首先获得-2的补码
        //2、-2的原码：10000000 00000000 00000000 00000010
        //3、-2的反码：11111111 11111111 11111111 11111101 （符号位不变，其它位按位取反）
        //3、-2的补码：11111111 11111111 11111111 11111110 （补码：反码+1）
        //4、取反~：   00000000 00000000 00000000 00000001   运算后的补码
        //5、 将运算后的补码 -> 原码 
        System.out.println(~-2);  // 1
        System.out.println(1>>2);
        // 本质：
        //x>>y  x/2^y
        //x<<y  x*2^y
    }
}

程序控制结构

顺序结构、循环结构、选择结构

分支控制if-else

基本语法1：

if（条件表达式）{

    执行代码块；

}

语法2：

if（条件表达式）{

    执行代码块；

}

else{

    执行代码块；

}

语法3：

if（条件表达式）{

    执行代码块；

}

else if（条件表达式）{

    执行代码块；

}

······

else{

    执行代码块；

}

import java.util.Scanner;
public class IfOperator{
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        // try{
            System.out.println("请输入你的年龄：");
            int age = myScanner.nextInt();
            if (age>18) {
                System.out.println("你成年了");
            }
            else{
                System.out.println("小屁孩");
            }
            System.out.println("请输入你的成绩：");
            double grade = myScanner.nextDouble();
            if (grade >= 90) {
                System.out.println("优秀");
            }
            else if (grade < 90 && grade >= 70) {
                System.out.println("良好");
            }
            else if (grade < 70 && grade >= 70) {
                System.out.println("几个");
            }
            else {
                System.out.println("不及格");
            }
            switch ((int)grade / 10) {
                case 9:System.out.println("优秀");
                break;
                case 8:
                case 7:System.out.println("良好");
                break;
                case 6:System.out.println("及格");
                break;
                default:System.out.println("不及格");
                break;
            }
        // }
        // catch{
        //     System.out.println("输入格式错误！");
        // }
    }
}

switch分支结构

语法：

switch(表达式){

        case 常量1：
        语句块1；
        break；
        case 常量1：
        语句块1；
        break；
        ····
        ····
        default:
        defautl语句块；
        break；

}

switch 细节：

for循环

语法：

for(循环变量初始化；循环条件；循环变量迭代)

{

    循环操作代码块；

}

for循环四要素：

(1)循环变量初始化；(2)循环条件；(3)循环操作；(4)循环变量迭代

public class ForOperator
{
    public static void main(String[] args) 
    {
        //打印1~100内9的倍数
        int count = 0;
        int sum = 0;
        for (int i = 0; i < 100; i++) 
        {
            if (i % 9 == 0) 
            {
                count++;
                sum += i;
            }
        }
        System.out.println(count);
        System.out.println(sum);
    }
}

while循环

语法：

循环变量初始化；

while（循环条件）

{

        循环体；
        循环变量迭代；

}

四要素：

(1)循环变量初始化；(2)循环条件；(3)循环操作；(4)循环变量迭代

注意事项和细节说明

1. 循环条件是返回一个布尔值的表达式
2. while 循环是先判断再执行语句

public class Whilewx{
    public static void main(String[] args) {
        // 某人有100,000元，没经过一次路口，需交费
        // 当现金>500000，每次交5%
        //      <=50000,每次交1000
        //计算该人可以经过多少次路口
        double money=100000;
        int count=0;
        while(true){
            if (money>50000) {
                money*=0.95;
                count++;
            }
            else if (money>1000) {
                money-=1000;
                count++;
            }
            else{
                break;
            }
        }
        System.out.println("可以过"+ count +"次路口");
    }
}

do-while

语法：

循环变量初始化；

do

{

    **循环体；**
    **循环变量迭代；**

}while（循环条件）；

注意：

1. do while 是关键字
2. 1也有循环四要素, 只是位置不一样
3. 先执行，再判断，也就是说，一定会至少执行一次
4. 最后 有一个 分号 ;

循环嵌套

介绍

1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。 【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内 层循环，才可结束外层的当次循环，开始下一次的循环
3. 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

public class MulFor
{
    public static void main(String[] args) 
    {
        //打印9*9乘法表
        for (int i=1; i<10; i++) 
        {
            for (int j=1;j<=i ;j++ ) 
            {
                System.out.print(j + " * " + i + " = " + j * i+'\t');
            }
            System.out.println();
        }
    }
}

打印空心金字塔：

import java.util.Scanner;
public class Stars
{
    public static void main(String[] args) 
    {
        // // 固定金字塔
        // for (int i=1; i<=5; i++)
        // {
        //     //在输出*之前要有空格
        //     for (int k=1;k<=5-i ;k++ ) 
        //     {
        //         System.out.println(" ");    
        //     }
        //     //控制打印每层*的个数
        //     for (int j=1; j<=2*i-1; j++) 
        //     {
        //         //当前行的第一个位置是*，最后一个也是*,最后一层全部输出*
        //         if (j==1||j==2*i-1||i==5)
        //         {
        //             System.out.print("*");    
        //         }
        //         else
        //         {
        //              System.out.print(" ");    
        //         }
        //     }
        //     System.out.println();
        // }
        Scanner myScanner = new Scanner(System.in);
        int rows= myScanner.nextInt();
        for (int i=1; i<=rows; i++)
        {
            //在输出*之前要有空格
            for (int k=1;k<=rows-i ;k++ ) 
            {
                System.out.print(" ");    
            }
            //控制打印每层*的个数
            for (int j=1; j<=2*i-1; j++) 
            {
                //当前行的第一个位置是*，最后一个也是*,最后一层全部输出*
                if (j==1||j==2*i-1||i==rows)
                {
                    System.out.print("*");    
                }
                else
                {
                     System.out.print(" ");    
                }
            }
            System.out.println();
        }
    }
}

break

介绍：

    break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环[for , while , do-while]中。

用户登陆：

import java.util.Scanner;
public class Breakwx
{
    public static void main(String[] args) 
    {
        int chance=3;
        Scanner myScanner = new Scanner(System.in);
        for(int i = 0;i < 3;i++)
        {
            System.out.println("请输入用户名：");
            String userName    = myScanner.next();
            System.out.println("请输入密码：");
            String pwd = myScanner.next();
            //if (userName.equals("微咲") && pwd.equals("888888"))  //使用==报错？？？
            if ("微咲".equals(userName) && "888888".equals(pwd)) //能避免空字符串
            {
                System.out.println("登陆成功");
                break;
            }
            System.out.println("登陆失败");
            chance--;
            System.out.println("还有"+ chance +"次机会");
            if (i==2) 
            {
                System.out.println("次数用光");
            }
        }
    }
}

continue

基本介绍：

1. continue 语句用于结束本次循环，继续执行下一次循环。
2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的 使用的规则一样.

return

退出当前函数、方法

数组

数组介绍

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。

即：数(数据)组(一组)就是一组数据

数组的定义

1、数组类型[] 数组名 = new 数据类型[大小]

int[] a = new int[5];

2、

先声明、后创建

3、

String[] strs = new String[]{“a”,”b”,”c”};

数组使用注意事项和细节

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3. 数组创建后，如果没有赋值，有默认值 int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
4. 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组
5. 数组的下标是从 0 开始的。
6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如 韩顺平循序渐进学 Java 零基础 第 148页 int [] arr=new int[5]; 则有效下标为 0-4
7. 数组属引用类型，数组型数据是对象(object)

数组赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
   int n1 = 2;
   int n2 = n1;
2. 数组在默认情况下是引用传递，赋的值是地址.

public class ArrayCopy{
    public static void main(String[] args) {
        //将 int[] arr1 = {10,20,30};拷贝到 arr2 数组中，要求空间独立~！
        int[] arr1 = {10,20,30};
        int[] arr3 = arr1;  //空间不独立
        //穿件一个新的数组arr2，开辟新的数据空间，大小为arr1.length
        int[] arr2 = new int[arr1.length];
        //遍历 arr1，copy到arr2中
        for (int i = 0;i<arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        for (int i=0; i<arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        //修改 arr1[1]的值
        arr1[1] = 9999;
        System.out.println(arr1[1]);
        System.out.println(arr2[1]);
        System.out.println(arr3[1]);
    }
}

数组反转

public class ArrayReverse {
    //编写一个 main 方法
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55, 66};
        //老韩思路
        //规律
        //1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
        //2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11}
        //3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11}
        //4. 一共要交换 3 次 = arr.length / 2
        //5. 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1                 -i]
        //代码
        //优化
        int temp = 0;
        int len = arr.length; //计算数组的长度
        for( int i = 0; i < len / 2; i++) {
            temp = arr[len - 1 - i];//保存
            arr[len - 1 - i] = arr[i];
            arr[i] = temp;
        }
        System.out.println("===翻转后数组===");
        for(int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + "\t");//66,55,44,33,22,11
        }
    }
}

数组扩容、缩减

扩容

import java.util.Scanner;
public class ArrayAdd {
    //编写一个 main 方法
    public static void main(String[] args) {
        /*
        要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
        1.原始数组使用静态分配 int[] arr = {1,2,3}
        2.增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
        3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
        思路分析
        1. 定义初始数组 int[] arr = {1,2,3}//下标 0-2
        2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
        3. 遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
        4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把 4 赋给 arrNew 最后一个元素
        5. 让 arr 指向 arrNew ; arr = arrNew; 那么 原来 arr 数组就被销毁
        6. 创建一个 Scanner 可以接受用户输入
        7. 因为用户什么时候退出，不确定，老师使用 do-while + break 来控制
        */
        Scanner myScanner = new Scanner(System.in);
        //初始化数组
        int[] arr = {1,2,3};
        do {
            int[] arrNew = new int[arr.length + 1];
            //遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
            for(int i = 0; i < arr.length; i++) {
                arrNew[i] = arr[i];
            }
            System.out.println("请输入你要添加的元素");
            int addNum = myScanner.nextInt();
            //把 addNum 赋给 arrNew 最后一个元素
            arrNew[arrNew.length - 1] = addNum;
            //让 arr 指向 arrNew, 
            arr = arrNew;
            //输出 arr 看看效果
            System.out.println("====arr 扩容后元素情况====");
            for(int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
            //问用户是否继续
            System.out.println("是否继续添加 y/n");
            char key = myScanner.next().charAt(0);
            if( key == 'n') { //如果输入 n ,就结束
                break;
            }
        }while(true);
        System.out.println("你退出了添加...");
    }
}

缩减

import java.util.Scanner;
public class ArrayReduce{
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        // 有一个数组 {1， 2， 3， 4， 5}， 可以将该数组进行缩减，提示用户是否继续缩减，
        //每次缩减最后那个元素。当只剩下最后一个元素，提示，不能再缩减。
        Scanner myScanner = new Scanner(System.in);
        while(true){
            System.out.println("是否继续删除元素：y/n");
            // char userInput = myScanner.next();
            // if (userInput == 'n') {
            //     break;
            // }
            char key = myScanner.next().charAt(0);
            if( key == 'n') { //如果输入 n ,就结束
                break;
            }
            System.out.println("当前数组大小为：" + arr.length);
            if (arr.length==1) {
                System.out.println("数组只有一个元素了，不能再缩减了！");
                break;
            }
            int[] arrNew = new int[arr.length - 1];
            for (int i=0; i < arr.length - 1; i++ ) {
                arrNew[i] = arr[i];
            }
            arr = arrNew;
            //遍历arr
            System.out.println("====arr 缩减后元素情况====");
            for (int i=0;i<arr.length; i++) {
                System.out.print(arr[i]+" ");
            }
        }
    }
}

二维数组

二维数组的声明

使用方式 1: 动态初始化

1. 语法: 类型[][] 数组名=new 类型[大小][大小]
2. 比如: int a[][]=new int[2][3]

使用方式 2: 动态初始化

1. 先声明：类型 数组名[][];
2. 再定义(开辟空间) 数组名 = new 类型[大小][大小]
3. 赋值(有默认值，比如 int 类型的就是 0)
4. 比如：int a[][]; a = new int[2][3]

使用方式 3: 动态初始化-列数不确定

二维数组，列数不确定

public class TwoDimensionalArray03 {
//编写一个 main 方法
public static void main(String[] args) {
/*
看一个需求：动态创建下面二维数组，并输出
i = 0: 1
i = 1: 2 2
i = 2: 3 3 3 一个有三个一维数组, 每个一维数组的元素是不一样的
*/
//创建 二维数组，一个有 3 个一维数组，但是每个一维数组还没有开数据空间
int[][] arr = new int[3][];
for(int i = 0; i < arr.length; i++) {//遍历 arr 每个一维数组
//给每个一维数组开空间 new
//如果没有给一维数组 new ,那么 arr[i]就是 null
arr[i] = new int[i + 1];
//遍历一维数组，并给一维数组的每个元素赋值
for(int j = 0; j < arr[i].length; j++) {
arr[i][j] = i + 1;//赋值
}
}
System.out.println("=====arr 元素=====");
//遍历 arr 输出
for(int i = 0; i < arr.length; i++) {
//输出 arr 的每个一维数组
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();//换行
}
}
}

使用方式 4: 静态初始化

1. 定义 类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}
2. 使用即可 [ 固定方式访问 ]

二维数组使用细节和注意事项

1. 一维数组的声明方式有:
   int[] x 或者 int x[]
2. 二维数组的声明方式有:
   int[][] y 或者 int[] y[] 或者 int y[][]
3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。
   比如： map[][] 是 一个二维数组
   int map [][] = {{1,2},{3,4,5}}
   由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，我们也称为列数不等 的二维数组

二维数组存放地址

杨辉三角

import java.util.Scanner;
public class YangHui{
    public static void main(String[] args) {
        /*
            使用二维数组打印一个 10 行杨辉三角
            1
            1 1
            1 2 1
            1 3 3 1
            1 4 6 4 1
            1 5 10 10 5 1
            规律
            1.第一行有 1 个元素, 第 n 行有 n 个元素
            2. 每一行的第一个元素和最后一个元素都是 1
            3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j]
            arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律
        */
            Scanner myScanner = new Scanner(System.in);
            System.out.println("请输入杨辉三角的行数rows：");
            int rows = myScanner.nextInt();
            int[][] yangHui = new int[rows][];
            for (int i = 0; i < yangHui.length; i++ ) {
                //给每个一维数组（行）开辟空间
                yangHui[i] = new int[i+1];
                //给每个一维数组（行）赋值
                for (int j = 0; j < yangHui[i].length; j++) {
                    //每一行的第一个元素和最后一个元素都是1
                    if (j == 0 || j == yangHui[i].length - 1) {
                        yangHui[i][j] = 1;
                    }else{
                        yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
                    }
                }
            }
            for (int i=0;i<yangHui.length;i++ ) {
                for (int j=0;j<yangHui[i].length ;j++ ) {
                    System.out.print(yangHui[i][j]+" ");
                }
                System.out.println();
            }
    }
}

排序

排序的介绍

排序是将多个数据，依指定的顺序进行排列的过程。

排序的分类：

• 内部排序:

指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择 式排序法和插入式排序法)；

• 外部排序法：
  数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。

冒泡排序法

冒泡排序（Bubble Sorting）的基本思想是：

通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素 的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

冒泡排序思想

查找

介绍：

在 java 中，我们常用的查找有两种:

1. 顺序查找 SeqSearch.java
2. 二分查找【二分法，我们放在算法讲解】

面对对象基础

类与对象

简介

类与对象

public class Object01 {
//编写一个 main 方法
public static void main(String[] args) {
/*
张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。
还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户输入小猫的名字时，
就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
则显示 张老太没有这只猫猫。
*/
//单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
//第 1 只猫信息
// String cat1Name = "小白";
// int cat1Age = 3;
// String cat1Color = "白色";
// //第 2 只猫信息
// String cat2Name = "小花";
// int cat2Age = 100;
// String cat2Color = "花色";
//数组 ===>(1)数据类型体现不出来(2) 只能通过[下标]获取信息，造成变量名字和内容
// 的对应关系不明确(3) 不能体现猫的行为
//第 1 只猫信息
// String[] cat1 = {"小白", "3", "白色"};
// String[] cat2 = {"小花", "100", "花色"};
//使用 OOP 面向对象解决
//实例化一只猫[创建一只猫对象]
//老韩解读
//1. new Cat() 创建一只猫(猫对象)
//2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1
//3. cat1 就是一个对象
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
cat1.weight = 10;
//创建了第二只猫，并赋给 cat2
//cat2 也是一个对象(猫对象)
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 100;
cat2.color = "花色";
cat2.weight = 20;
//怎么访问对象的属性呢
System.out.println("第 1 只猫信息" + cat1.name
+ " " + cat1.age + " " + cat1.color + " " + cat1.weight);
System.out.println("第 2 只猫信息" + cat2.name
+ " " + cat2.age + " " + cat2.color + " " + cat2.weight);
}
}
//使用面向对象的方式来解决养猫问题
//
//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
//属性/成员变量
String name; //名字
int age; //年龄
String color; //颜色
//double weight; //体重
//行为
}