02-第二章 标识符与关键字 数据类型 运算符 控制语句

day05课堂笔记

1、标识符
1.1、标识符可以标识什么,什么是标识符,怎么理解这个概念!
1.2、标识符的命名规则
1.3、标识符的命名规范
本小结最终的要求是:随意给出一个单词,判断它是否是合法的标识符。

2、每一天你会编写很多程序,你会遇到很多编译错误,也会遇到很多运行错误,
你是否需要准备一个单独的文件来记录这些信息,以及记录这些信息是怎么导致
的,原因是什么,怎么去解决的,解决办法是啥????
非常有必要的,要想成为一个调错高手,这个有必要进行一下。

3、关键字

3.1、什么是关键字?
在SUN公司开发Java语言的时候,提前定义好了一些具有特殊含义的单词,
这些单词全部小写,具有特殊含义,不能用作标识符。

3.2、凡是在EditPlus中以蓝色字体形式存在的都是关键字,具有特殊含义。

3.3、切记:
java语言中的所有关键字都是全部小写。
注意:java语言中是严格区分大小写的。public和Public不一样。
Class和class不一样。static和Static也不一样。

复制代码
class T{
}

// 在123.java文件中定义public的类可以吗?
// 因为之前有一条规则是这样说的:public的类可以没有
// 但如果有public的类,也只能有1个,并且public的类的
// 名字必须和源文件名保持一致。
//public class 123 { // 但是最终尴尬了,因为123不能做标识符。是错误的标识符。
//}
复制代码
复制代码
/*
    1、在java程序当中,使用EditPlus工具进行代码编写的时候,
    有一些单词是蓝色,有的是红色,有的绿色,有的是黑色,有
    的是紫色,有的是粉色....

    2、注意:在java源代码当中,在EditPlus工具中显示的高亮颜色为黑色时,
    这个单词属于标识符。

    3、标识符可以标识什么?
        可以标识:
            类名
            方法名
            变量名
            接口名
            常量名
            ......
    
    4、到底什么是标识符呢?
        一句话搞定:凡是程序员自己有权利命名的单词都是标识符。
    
    5、标识符可以随意编写吗,有命名规则吗?有
        什么是命名规则?
            命名规则属于语法机制,必须遵守,不遵守命名规则标识不符合语法,
            这样,编译器会报错。

        规则1:标识符只能由数字、字母(包括中文)、下划线_、美元符号$组成,
        不能含有其它符号。

        规则2:标识符不能以数字开头

        规则3:关键字不能做标识符。例如:public class static void 这些蓝色的字体
        都是关键字,关键字是不能做标识符的。

        规则4:标识符是严格区分大小写的。大写A和小写a不一样。

        规则5:标识符理论上是没有长度限制的。
        
*/
public class BiaoShiFuTest{
    // main是一个方法的名称,属于标识符
    // 但是这个标识符不能修改,因为这个main是SUN固定死的。
    public static void main(String[] args){
    }

    //doSome是一个方法名,可以改成其他的名字
    public static void doSome(){
        // k是一个变量名
        int k = 100;
        // nianLing 是一个变量名
        int nianLing = 20;
    }
}

/*
    编译报错,错误信息是:
        错误: 需要<标识符>
        错误原因:编译器检测到class这个单词,那么编译器会从class这个
        单词后面找类名,而类名是标识符,编译器找了半天没有找到标识符,
        因为123ABC不是标识符,所以编译器提示的错误信息是:需要<标识符>

        解决办法:
            将123ABC修改为合法的标识符。
*/
class Y123ABC{
}

// 类名是标识符,标识符“中”不能有空格
/*
编译器错误信息是:
    错误: 需要'{'
    编译器检测到class,然后找class后面的标识符,编译器找到了一个合法的标识符
    叫做“Hello”,然后编译器继续往后找“{”,结果没有找到“{”,所以报错了。

    解决办法:
        办法1:是把World删除
        办法2:把空格删除
*/
/*
class Hello World{
}
*/

class Hello{
}

class HelloWorld                   {
}

class _A{
}

class _$1Aa你{
}

// 错误: 需要<标识符>
// 关键字不能做标识符
/*
class public {
}
*/

// 这个可以,因为 public1 不是关键字,可以用。
class public1 {
}

class b {
}

class B {
}


// 虽然java中的标识符严格区分大小写
// 但是对于类名来说,如果一个java源文件中同时出现了:A类和a类
// 那么谁在前就生成谁。大家以后最好不要让类名“相同”。
// 最好类名是不同的。
class HelloWorld2{
}

class helloWorld2{
}
复制代码
复制代码
/*
    题目:
        创建一个java文件,起名 123.java可以吗?
            可以,完全可以,在windows操作系统中文件名叫做:123.java没毛病。
        123其实并不是标识符。只是一个文件名。
        只不过在123.java文件中无法定义public的类。
    
    标识符除了命名规则之外,还有命名规范:
        1、命名规则和命名规范有什么区别?
            命名规则是语法,不遵守就会编译报错。
            命名规范只是说,大家尽量按照统一的规范来进行命名,不符合规范也行,
            代码是可以编译通过的,但是你的代码风格和大家不一样,这个通常也是
            不允许的。

            规则类似于:现实世界中的法律。
            规范类似于:现实世界中的道德。

            统一按照规范进行的话,代码的可读性很好。
            代码很容易让其它开发人员理解。

        2、具体的命名规范是哪些?

            规范1:见名知意(这个标识符在起名的时候,最好一看这个单词就知道啥意思。)

            规范2:遵循驼峰命名方式,什么是驼峰(一高一低,一高一低...)
                驼峰有利于单词与单词之间很好的进行分隔
                BiaoShiFuTest,这个很好,一眼就能看出来是4个单词。

            规范3:类名、接口名有特殊要求
                类名和接口名首字母大写,后面每个单词首字母大写。
                    StudentTest、UserTest ,这是类名、接口名。

            规范4:变量名、方法名有特殊要求
                变量名和方法名首字母小写,后面每个单词首字母大写。
                    nianLing(NianLing这样就不符合了。)
                    mingZi(MingZi这样也不符合了。)
            
            规范5:所有“常量”名:全部大写,并且单词和单词之间采用下划线衔接。
                USER_AGE :用户年龄
                MATH_PI:固定不变的常量3.1415926.....
*/
public class IdentifierTest{
    public static void main(String[] args){
        // 以下代码看不懂没关系,别着急。
        // 主要看两个汉语拼音,可读性很强。
        // nianLing和mingZi都是黑色字体的标识符。
        int nianLing = 20;
        String mingZi = "zhangsan";
    }
}
复制代码

 


3.4、那么关键字有哪些呢,我们需要背会吗?需要单独去记忆吗?
关键字:
public
static
void
class
byte
short
int
long
float
double
boolean
char
true
false
if
while
for
private
protected
........
对于这些关键字来说大家不需要单独花费时间去记忆,
随着后面程序的积累,你会接触到所有的关键字。

4、变量
4.1、字面量
字面量就是数据
数据就是字面量
是一个东西。

10 100 123 :整型
1.34 3.14 2.0:浮点型
true false :布尔型
'a' '国':字符型
"a" "abc" "国" "中国":字符串型

10:整数,是一个数字
"10":它不是数字,是一个字符串,或者说,它属于“文字类”的。
性质完全不同,在计算机中的对应的二进制码也是完全不同的。

4.2、变量
变量的理解
什么是变量?
变量就是一个存数据盒子。(盒子大小谁来决定啊?数据类型)
在内存中的最基本的存储单元。
存数据用的,而且这个数据是可变的,所以叫做变量。

变量的使用

变量的三要素?
数据类型、变量名、值 (值就是数据,就是字面量。)
int i = 100;

java中的变量必须先声明,再赋值才能访问(必须手动赋值。)
int k; System.out.println(k); 这样是不行的。

可以在一行上声明多个变量:
int a, b, c = 100;
c变量赋值100,a,b变量只声明了没有赋值。
int a = 10, b = 20, c = 100;
可以这样每个都赋值。

声明和赋值可以分开,也可以一起做!!!
int i;
i = 100; // 先声明再赋值
int k = 200; // 声明的同时赋值

在“同一个域”当中,变量名不能重名!!!!!!
但可以重新赋值!!!!!!
{
int i = 100;
//double i = 2.0; // 重名了编译器会报错,不允许。
i = 300; // 可以重新赋值。
}

到底什么叫做同一个域?????
这个目前不太好解释,大家记住吧:一个大括号代表一个域。
{A域
{B域
{C域
}
}
}
A域包括B域,B域包括C域。

变量的分类
根据位置进行分类:记住就行
在方法体当中声明的变量叫做局部变量。
public static void m1(){
//局部变量,方法执行结束之后内存释放。
int k = 100;
int i = 200;
}
在方法体外以及类体内声明的变量叫做成员变量。
public class T{
public static void x(){

}
// 成员变量
int i = 200;
}

变量的作用域
出了大括号就不认识了。别的先别管。
{
int i = 100;
{
在这里可以访问i
}
}

{
在这里是无法访问i变量。
}

 

复制代码
/*
    变量的第一个测试程序:Var是变量

    1、关于程序当中的数据?
        开发软件是为了解决现实世界中的问题。
        而现实世界当中,有很多问题都是使用数据进行描述的。
        所以软件执行过程中最主要就是对数据的处理。

        软件在处理数据之前需要能够表示数据,在java代码中
        怎么去表示数据呢?在java中有这样的一个概念:字面量。

        注意:在java语言中“数据”被称为“字面量”。
        10
        1.23
        true
        false
        'a'
        "abc"
        以上这些都是数据,在程序中都被叫做“字面量”。

        字面量可以分为很多种类:
            整数型字面量:1 2 3 100 -100 -20 ....
            浮点型字面量:1.3 1.2 3.14.....
            布尔型字面量:true、false没有其它值了,表示真和假,true表示真,false表示假

            字符型字面量:'a'、'b'、'中'
            字符串型字面量:"abc"、"a"、"b"、"中国"

            其中字符型和字符串型都是描述了现实世界中的文字:
                需要注意的是:
                    所有的字符型只能使用单引号括起来。
                    所有的字符串型只能使用双引号括起来。
                
                字符型一定是单个字符才能成为“字符型”

                在语法级别上怎么区分字符型和字符串型?
                    主要看是双引号还是单引号。
                    单引号的一定是字符型。
                    双引号的一定是字符串型。

    2、什么是变量?
        
*/
public class VarTest01{
    public static void main(String[] args){
        System.out.println(100);
        System.out.println(3.14);
        System.out.println(true);
        System.out.println(false);
        System.out.println('a');
        System.out.println('中');
        System.out.println("abc");
        System.out.println("国"); // 这不属于字符型,因为使用双引号括起来了,所以它是字符串。

        // 编译报错。ab是一个串,不是字符型,不能用单引号。
        //System.out.println('ab');

        System.out.println('好'); // 属于字符型
        System.out.println("好"); // 属于字符串型
        System.out.println("1"); //属于整数型吗?不是,是字符串。
        System.out.println("true"); // 属于布尔型吗?不是,是字符串。
        System.out.println("3.14"); // 字符串型

        System.out.println(1); // 整数型
        System.out.println(3.14); // 浮点型
        System.out.println(true); // 布尔型
        System.out.println(false); // 布尔型

        //分析一下:如果只有字面量,没有变量机制的话,有什么问题?
        // 10 是一个整数型数据,在内存中占有一定的空间(CPU 内存 硬盘)
        // 10 + 20 = 30
        // 在内存中找一块空间存储10,再找一块空间存储20,CPU负责“+”运算,算完
        // 之后的结果是30,那么这个30也会在内存当中找一块临时的空间存储起来。
        // 思考:以下的三个10在内存当中是一块空间,还是三块不同的空间呢?
        // 以下虽然都是10,但是这3个10占用三块不同的内存空间。
        System.out.println(10);
        System.out.println(10);
        System.out.println(10); // 只有“字面量”机制的话,是远远不够的,因为只有字面量内存是无法重复利用的。

        // 定义/声明一个变量,起名i
        int i = 1000;
        // 以下这5次访问都是访问的同一块内存空间。(这样使用变量之后,内存空间就得到了复用。)
        System.out.println(i);
        System.out.println(i);
        System.out.println(i);
        System.out.println(i);
        System.out.println(i);

        // 以下程序表示访问的是字符i以及字符串i,以下的这两个i和以上的i变量没有任何关系。
        System.out.println('i');
        System.out.println("i");

    }

}
复制代码

 

复制代码
/**
* 变量测试类2
* @author 杜聚宾
* @version 1.5
* @since 1.0
*/
/*
    什么是变量?
        变量其实就是内存当中存储数据的最基本的单元。
        变量就是一个存储数据的盒子。

    在java语言当中任何数据都是有数据类型的,其中整数型是:int
        没有为什么,java中规定的,整数型就是:int
    
    当然,在java中除了数据类型int之外,还有其它的类型,例如带小数的:double等。。。

    数据类型有什么用呢?
        记住:不同的数据类型,在内存中分配的空间大小不同。
        也就是说,Java虚拟机到底给这个数据分配多大的空间,主要还是看这个变量的数据类型。
        根据不同的类型,分配不同大小的空间。
    
    对于int这种整数类型,JVM会自动给int分配4个字节大小的空间。

    1个字节=8个比特位
    1个比特位就是一个1或0. 注意:比特位是二进制位。
    int是占用多少个二进制位?1个int占有32个二进制位(bit位)

    int i = 1; 实际上在内存中是这样表示的:
        00000000 00000000 00000000 00000001
    int i = 2;
        00000000 00000000 00000000 00000010
    
    二进制位就是:满2进1位(0 1 10 11 100 101....)
    十进制位就是:满10进1位(1 2 3 4 5 6 7 8 9 10)

    对于一个变量来说,包括三要素:
        变量的数据类型
        变量的名字
        变量中保存的值

        类型+名字+值
            类型决定空间的大小。
            起个名字是为了以后方便访问。(以后在程序中访问这个数据是通过名称来访问的。)
            值是变量保存的数据。

    变量名属于标识符吗?
        变量名命名规范中是怎么说的?
            首字母小写,后面每个单词首字母大写,遵循驼峰命名方式,见名知意。
    
    变量怎么声明/定义,语法格式是什么?
        数据类型 变量名;
        例如:
            int nianLing;
    
    在java语言中有一个规定,变量必须先声明,再赋值才能访问。(没有值相当于这个空间没有开辟。)

    在java语言中怎么给一个变量赋值呢,语法格式是什么?
        记住:使用一个运算符,叫做“=”,这个运算符被称为赋值运算符。
        赋值运算符“=”的运算特点是:等号右边先执行,执行完之后赋值给左边的变量。
    
    变量可以声明的时候赋值吗?可以的。
    
*/
public class VarTest02{

    /**
    * 这是一个程序的入口
    * @param args是main方法的参数
    */
    public static void main(String[] args){

        // 定义一个int类型的变量,起名nianLing,该变量用来存储人的年龄。
        int nianLing;
        
        // 变量声明之后,没有手动赋值,可以直接访问吗?
        // 编译报错:错误: 可能尚未初始化变量nianLing
        //System.out.println(nianLing);

        // 给变量赋值
        nianLing = 45;
        System.out.println(nianLing); // 这是访问变量。

        System.out.println("nianLing"); // 这是访问字符串。

        // 变量:可以变化的量。
        // 重新赋值
        nianLing = 80;
        System.out.println(nianLing);

        // 再次重新赋值
        nianLing = 90;
        System.out.println(nianLing);

        // 体重80kg
        int tiZhong = 80;
        System.out.println(tiZhong);
    }
}
复制代码
复制代码
public class VarTest03{
    public static void main(String[] args){
        // 在这里可以访问k变量吗?
        // 注意:方法体当中的代码遵循自上而下的顺序依次逐行执行。
        // 所以以下程序编译报错。
        System.out.println(k); //错误: 找不到符号

        // 只有执行了这一行代码,k变量在内存中才会开辟空间。
        int k = 10;
    }
}
复制代码
复制代码
// 重要的结论:在同一个域当中(这个域怎么理解,后面讲),变量名不能重名,不能重复声明。
// 变量可以重新赋值,但在同一个域当中,不能重复声明。
public class VarTest04{
    public static void main(String[] args){
        // 声明一个整数型的变量起名nianLing,存储值20
        int nianLing = 20;
        System.out.println(nianLing);

        // 给变量重新赋值
        nianLing = 30;
        System.out.println(nianLing);

        // 这个可以吗?不行
        // 错误信息:错误: 已在方法 main(String[])中定义了变量 nianLing
        /*
        int nianLing = 100;
        System.out.println(nianLing); 
        */
    }
}
复制代码
复制代码
// 编译报错:i变量重复定义了。(和类型没有关系。不能同名。)
public class VarTest05{
    public static void main(String[] args){

        // 整数型
        int i = 100;    

        System.out.println(i);

        // 浮点型(带小数的)
        // 错误: 已在方法 main(String[])中定义了变量 i
        double i = 1.2;

        System.out.println(i);

    }
}
复制代码
复制代码
// 一行上可以同时声明多个变量吗?
// 答案:可以一行声明多个变量。
public class VarTest06{
    public static void main(String[] args){
        // 声明三个变量,都是int类型,起名a,b,c
        // 通过测试得出结论是:a,b没有赋值,c赋值100
        int a, b, c = 100;

        // 变量必须先声明,再赋值,才能访问,a,b两个变量赋值了吗?
        //错误: 可能尚未初始化变量a
        //System.out.println(a);
        //错误: 可能尚未初始化变量b
        //System.out.println(b);
        System.out.println(c);

        // 给a赋值
        a = 200;
        // 给b赋值
        b = 300;
        System.out.println(a);
        System.out.println(b);
        
    }
}
复制代码
复制代码
/*
    1、关于变量的一个分类(这个需要“死记硬背”。)
        变量根据出现的位置进行划分:
            在方法体当中声明的变量:局部变量。
            在方法体之外,类体内声明的变量:成员变量。

            重点依据是:声明的位置。

    2、注意:局部变量只在方法体当中有效,方法体执行结束该变量的内存就释放了。
*/
public class VarTest07{

    // 这里可以定义变量吗?可以的
    // 成员变量
    int i = 100;

    // 主方法
    public static void main(String[] args){
        // 局部变量
        int k = 100; // main方法结束k内存空间释放。
    }

}
复制代码
复制代码
/*
    变量的作用域?
        1、什么是作用域?
            变量的有效范围。
        2、关于变量的作用域,大家可以记住一句话:
            出了大括号就不认识了。(死记这句话。)
        3、java中有一个很重要的原则:
            就近原则。(不仅java中是这样,其它编程语言都有这个原则。)
            哪个离我近,就访问哪个。
*/

public class VarTest08{

    // 成员变量
    int i = 10000;

    public static void main(String[] args){
        // 局部变量
        int i = 100; // 这个i的有效范围是main方法。
        System.out.println(i); // 这个i是多少?

        // 同一个域当中,这是不允许的。
        //int i = 90;  

        // 考核一下:以下编写for循环你看不懂,没关系,后面会将。
        for(int n = 0; n < 10; n++){ // 这里声明的n变量只属于for域。for结束后n释放没了。
            // 这里没有编写代码。
        }

        // for循环执行结束之后,在这里访问n变量可以吗?
        //System.out.println(n);  //错误: 找不到符号

        int k; // 属于main域。
        for(k = 0; k < 10; k++){

        }
        // 能否继续访问k呢?
        System.out.println(k);
    }

    // 这个方法怎么定义先不用管,后面会学习。
    public static void x(){
        // 在这个位置上能访问i吗?
        // 错误: 找不到符号
        // System.out.println(i); // i是无法访问的。

        // 可以定义一个变量起名i吗?
        // 这个i的有效范围是x方法。
        // 局部变量
        int i = 200; // 所以这个i和main方法中的i不在同一个域当中。不冲突。
    }
}
复制代码

 

 

 

 

day06课堂笔记

1、数据类型

1.1、数据类型有什么用?
数据类型用来声明变量,程序在运行过程中根据不同的数据类型分配不同大小的空间。
int i = 10;
double d = 1.23;
i变量和d变量类型不同,空间大小不同。

1.2、数据类型在java语言中包括两种:

第一种:基本数据类型
基本数据类型又可以划分为4大类8小种:
第一类:整数型
byte,short,int,long (没有小数的)
第二类:浮点型
float,double (带有小数的)
第三类:布尔型
boolean:只有两个值true和false,true表示真,false表示假
第四类:字符型
char:java中规定字符型字面量必须使用单引号括起来。属于文字。

8小种:
byte,short,int,long
float,double
boolean
char

第二种:引用数据类型
字符串型String属于引用数据类型。
String字符串不属于基本数据类型范畴。
java中除了基本数据类型之外,剩下的都是引用数据类型。
引用数据类型后期面向对象的时候才会接触。

1.3、8种基本数据类型中
整数型:byte short int long有什么区别?
浮点型:float和double有什么区别?
区别:占用的空间大小不同。

关于计算机存储单位?
计算机只能识别二进制。(1001101100...)
1字节 = 8bit(8比特)--> 1byte = 8bit
1bit就是一个1或0.
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

byte b = 2; 在计算机中是这样表示的:00000010
short s = 2; 在计算机中是这样表示的:00000000 00000010
int i = 2;在计算机中是这样表示的:00000000 00000000 00000000 00000010
...

类型 占用字节数量(byte)
------------------------------------
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1 (1byte的1或0,00000001(true)或00000000(false))
char 2

关于二进制?
二进制???
1 2 3 4 5 6 7
1 10 11 100 101 110 111 ....

十进制转换成二进制
125 转换成二进制???
办法:除以2,然后余数逆序输出。
1111101

二进制转换成十进制
2的2次方 2的1次方 2的0次方
1 1 1
4 2 1
1*4 + 1*2 + 1*1 = 7

2的2次方 2的1次方 2的0次方
1 0 1
4 2 1
1*4 + 0*2 + 1*1 = 5

1.4、byte类型的取值范围?
byte是 [-128 ~ 127] 共可以标识256个不同的数字。
byte类型的最大值是怎么计算出来的?
byte是1个字节,是8个比特位,所以byte可以存储的最大值是:
01111111
注意:在计算机当中,一个二进制位最左边的是符号位,当为0时表示正数,
当为1时表示负数。所以byte类型最大值是:01111111
那么是不是2的7次方-1呢?
是不是:10000000(前边是一个二进制) - 1

byte类型最大值是:2的7次方 - 1.

有几个取值范围需要大家记住:
(1个字节)byte: [-128 ~ 127]
(2个字节)short:[-32768 ~ 32767] 可以表示65536个不同的数字
(4个字节)int: [-2147483648 ~ 2147483647]
(2个字节)char: [0~65535] 可以表示65536个不同的数字

short和char实际上容量相同,不过char可以表示更大的数字。
因为char表示的是文字,文件没有正负之分,所以char可以表示
更大的数字。

1.5、对于8种基本数据类型来说:
其中byte,short,int,long,float,double,boolean,这7种类型计算机表示起来
比较容易,因为他们都是数字。其中布尔类型只有两个值true和false,实际上
true和false分别在C++中对应的是1和0,1为true,false为0。

对于char类型来说计算机表示起来比较麻烦,因为char对应的是文字,每一个国家
的文字不一样,文字不能直接通过“自然算法”转换成二进制。这个时候怎么办?
字符编码诞生了。

什么是字符编码?
字符编码是人为的定义的一套转换表。
在字符编码中规定了一系列的文字对应的二进制。
字符编码其实本质上就是一本字典,该字段中描述了文字与二进制之间的对照关系。
字符编码是人为规定的。(是某个计算机协会规定的。)

字符编码涉及到编码和解码两个过程,编码和解码的时候必须采用同一套字符编码
方式,不然就会出现乱码。

关于字符编码的发展过程?
起初的时候计算机是不支持文字的,只支持科学计算。实际上计算机起初是为了
战争而开发的,计算导弹的轨道....

后来随着计算机的发展,计算机开始支持文字,最先支持的文字是英文,英文
对应的字符编码方式是:ASCII码。

ASCII码采用1byte进行存储,因为英文字母是26个。(键盘上所有的键全部算上也
超不过256个。1byte可以表示256种不同的情况。所以英文本身在计算机方面就占有
优势。)
'a' --(采用ASCII码进行编码)-> 01100001
01100001 --(采用ASCII码进行解码)-> 'a'
如果编码和解码采用的不是同一个编码方式,会出现乱码。
'b' ---> 98
'c' ---> 99...
'a' ---> 97

'A' ---> 65
'B' ---> 66
...

'0' ---> 48 (这个'0'不是那个0,是文字'0')
'1' ---> 49

随着计算机语言的发展,后来国际标准组织制定了ISO-8859-1编码方式,
又称为latin-1编码方式,向上兼容ASCII码。但不支持中文。

后来发展到亚洲,才支持中文,日文,韩文....
中文这块的编码方式:GB2312<GBK<GB18030 (容量的关系)
以上编码方式是简体中文。

繁体中文:big5(台湾使用的是大五码。)

在java中,java语言为了支持全球所有的文字,采用了一种字符编码方式
叫做unicode编码。unicode编码统一了全球所有的文字,支持所有文字。
具体的实现包括:UTF-8 UTF-16 UTF-32....

需要记住:
ASCII('a'是97 'A'是65 '0'是48...)
ISO-8859-1(latin-1)
GB2312
GBK
GB18030
Big5
unicode(utf8 utf16 utf32)

2、八种基本数据类型详解
字符型 char
整数型 byte short int long
浮点型 float double
布尔型 boolean

 

复制代码
/*
    1、在java语言中boolean类型只有两个值,没有其他值:
        true和false。
        不像C或者C++,C语言中1和0也可以表示布尔类型。

    2、boolean类型在实际开发中使用在哪里呢?
        使用在逻辑判断当中,通常放到条件的位置上(充当条件)
*/
public class BooleanTest01{
    public static void main(String[] args){
        //错误: 不兼容的类型: int无法转换为boolean
        //boolean xingBie = 1;

        // 需求规定:如果为true则表示男,为false则表示女。
        //boolean sex = true;
        boolean sex = false;

        int a = 10;
        int b = 20;
        System.out.println(a < b); // true
        System.out.println(a > b); // false

        //boolean flag = a < b;
        boolean flag = (a < b); // 运算符是有优先级的,不确定可以加小括号。加了小括号就一定是先执行的。
        System.out.println(flag); // true

        // 后面我们会学习if语句
        // if语句是一个条件语句
        // 可以实现什么功能呢?例如:如果A账户的钱充足,才可以向B账户转账。
        // 例如:如果这个布尔型值是true,则表示男性,为false则表示女性。
        if(sex){
            System.out.println("男");
        }else{
            System.out.println("女");
        }

        // 以上的if语句看不懂没关系。后面会学习。
    }
}
复制代码

 

复制代码
/*
    字符型:
        char

        1、char占用2个字节。
        2、char的取值范围:[0-65535]
        3、char采用unicode编码方式。
        4、char类型的字面量使用单引号括起来。
        5、char可以存储一个汉字。
*/
public class CharTest01{
    public static void main(String[] args){
        // char可以存储1个汉字吗?
        // 可以的,汉字占用2个字节,java中的char类型占用2个字节,正好。
        char c1 = '中';
        System.out.println(c1);

        char c2 = 'a';
        System.out.println(c2);

        // 0如果加上单引号的话,0就不是数字0了,就是文字0,它是1个字符。
        char c3 = '0';
        System.out.println(c3);

        // 错误: 不兼容的类型: String无法转换为char
        //char c4 = "a";

        // 错误: 未结束的字符文字
        //char c5 = 'ab';

        // 错误: 未结束的字符文字
        //char c6 = '1.08';

    }
}
复制代码
复制代码
/*
    关于java中的转义字符
        java语言中“\”负责转义。
            \t 表示制表符tab
*/
public class CharTest02{
    public static void main(String[] args){

        // 普通的't'字符
        char c1 = 't';
        System.out.println(c1);
        
        //char x = 'ab';

        // 根据之前所学,以下代码应该报错。
        // 经过测试以下代码 \t 实际上是1个字符,不属于字符串
        // 两个字符合在一起表示一个字符,其中 \t 表示“制表符tab”
        char c2 = '\t'; //相当于键盘上的tab键

        System.out.println("abcdef");
        System.out.println("abctdef");
        // \的出现会将紧挨着的后面的字符进行转义。\碰到t表示tab键。
        System.out.println("abc\tdef");
        
        /*
            System.out.println(); 换行
            System.out.print(); 不换行
        */
        System.out.print("HelloWorld");
        System.out.println("123abcdef");

        System.out.print("abc");
        //char c3 = 'n'; // 普通的n字符
        char c3 = '\n'; // 换行符
        //System.out.print(c3);
        System.out.println(c3);
        System.out.println("def"); 

        // 假设现在想在控制台输出一个 ' 字符怎么办?
        // 错误: 空字符文字
        //System.out.println(''');
        // \' 表示一个普通不能再普通的单引号字符。(\'联合起来表示一个普通的 ')
        System.out.println('\'');

        // 假设现在想在控制台输出一个 \ 字符怎么办?
        //错误: 未结束的字符文字
        //System.out.println('\');
        // 在java中两个反斜杠代表了一个“普通的反斜杠字符”
        System.out.println('\\');

        // 双引号括起来的是字符串
        System.out.println("test");
        // 希望输出的结果是:"test"
        // 错误: 需要')'
        //System.out.println(""test"");
        System.out.println("“test”"); //内部的双引号我用中文的行吗?可以。

        System.out.println("");
        // 编译报错。
        //System.out.println(""");
        //System.out.println("\"");
        System.out.println("\"test\"");

        // 这个可以输出吗?
        // 这个不需要专门进行转义。
        // 这个 ' 在这里只是一个普通的字符,不具备特殊含义。
        System.out.println("'");

        //以下都有问题
        //System.out.println(''');
        //System.out.println(""");

        // 可以的。
        System.out.println("'这样呢'");

        // 编译报错,因为:4e2d 是一个字符串
        // 错误: 未结束的字符文字
        //char x = '4e2d';

        // 反斜杠u表示后面的是一个字符的unicode编码。
        // unicode编码是十六进制的。
        char x = '\u4e2d';
        System.out.println(x); // '中'
    }
} 
/*
十六进制,满16进1位:
    1 2 3 4 5 6 7 8 9 a b c d e f 10
    11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20...

八进制:
    0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20.....
*/
复制代码
复制代码
/*
    1、整数能否直接赋值给char
    2、char x = 97;
        这个java语句是允许的,并且输出的结果是'a'
        经过这个测试得出两个结论:
            第一个结论:当一个整数赋值给char类型变量的时候,会自动转换成char字符型,
            最终的结果是一个字符。

            第二个结论:当一个整数没有超出byte short char的取值范围的时候,
            这个整数可以直接赋值给byte short char类型的变量。
*/
public class CharTest03{
    public static void main(String[] args){
    
        char c1 = 'a';
        System.out.println(c1);

        // 这里会做类型转换吗?
        // 97是int类型(这是java中规定,默认当做int处理)
        // c2是char类型
        //char c2 = (char)97; // 不需要这样做。
        char c2 = 97;
        System.out.println(c2); // 'a'

        // char类型取值范围:[0~65535]
        char c3 = 65535; // 实际上最终是一个“看不懂”的字符。
        System.out.println(c3);

        //错误: 不兼容的类型: 从int转换到char可能会有损失
        //char c4 = 65536;

        // 怎么解决以上问题?
        char c4 = (char)65536;

        byte x = 1;
        short s = 1;
        char c = 1;

    }
}
复制代码
复制代码
/*
    关于java语言中的浮点型数据
        浮点型包括:
            float            4个字节
            double        8个字节
        
        float是单精度
        double是双精度

        double更精确

        比如说:
            10.0 / 3 如果采用float来存储的话结果可能是:3.33333
            10.0 / 3 如果采用double来存储的话结果可能是:3.3333333333333
        
        但是需要注意的是,如果用在银行方面或者说使用在财务方面,double
        也是远远不够的,在java中提供了一种精度更高的类型,这种类型专门
        使用在财务软件方面:java.math.BigDecimal (不是基本数据类型,属于
        引用数据类型。)
    
        float和double存储数据的时候都是存储的近似值。
        为什么?
            因为现实世界中有这种无线循环的数据,例如:3.3333333333333....
            数据实际上是无限循环,但是计算机的内存有限,用一个有限的资源
            表示无限的数据,只能存储近似值。
        
        long类型占用8个字节。
        float类型占用4个字节。
        哪个容量大?
            注意:任意一个浮点型都比整数型空间大。
            float容量 > long容量。
    
    java中规定,任何一个浮点型数据默认被当做double来处理。
    如果想让这个浮点型字面量被当做float类型来处理,那么
    请在字面量后面添加F/f。
        1.0 那么1.0默认被当做double类型处理。
        1.0F 这才是float类型。(1.0f)
*/
public class FloatTest01{
    public static void main(String[] args){

        // 这个不存在类型转换
        // 3.1415926是double类型
        // pi是double类型
        double pi = 3.1415926;
        System.out.println(pi);

        // 这个可以吗?
        //错误: 不兼容的类型: 从double转换到float可能会有损失
        //float f = 3.14;

        // 怎么修改以上的代码呢?
        // 第一种方式:在字面量后面添加F/f
        //float f = 3.14f;
        //float f = 3.14F;

        // 第二种方式:强制类型转换,但可能损失精度。谨慎使用。
        float f = (float)3.14;
        System.out.println(f);

        // 分析这个程序,可以编译通过吗?
        // 错误: 不兼容的类型: 从double转换到int可能会有损失
        // 原理:先将5转换成double类型,然后再做运算,结果是double
        // 大容量无法直接赋值给小容量,需要强转。
        //int i = 10.0 / 5;

        // 怎么修改
        int i = (int)10.0 / 5;
        System.out.println(i); // 2

        // 可以这样修改吗?强转的时候只留下整数位。
        int x = (int)(10.0 / 5);
        System.out.println(x); // 2
    }
}
复制代码
复制代码
/*
    整数型在java语言中共4种类型:
        byte    1个字节  最大值127
        short    2个字节  最大值32767
        int    4个字节  2147483647是int最大值,超了这个范围可以使用long类型。
        long    8个字节

        1个字节 = 8个二进制位
        1byte = 8bit

        对于以上的四个类型来说,最常用的是int。
        开发的时候不用斤斤计较,直接选择使用int就行了。
    
    在java语言中整数型字面量有4种表示形式:
        十进制:最常用的。
        二进制
        八进制
        十六进制
*/
public class IntTest01{
    public static void main(String[] args){
        // 十进制
        int a = 10; 
        System.out.println(a); // 10

        // 八进制
        int b = 010;
        System.out.println(b); // 8

        // 十六进制
        int c = 0x10;
        System.out.println(c); // 16

        int x = 16; //十进制方式
        System.out.println(x);

        // 二进制(JDK8的新特性,低版本不支持。)
        int d = 0b10;
        System.out.println(d); // 2
    }
}
复制代码
复制代码
/*
    在java中有一条非常重要的结论,必须记住:
        在任何情况下,整数型的“字面量/数据”默认被当做int类型处理。(记住就行)
        如果希望该“整数型字面量”被当做long类型来处理,需要在“字面量”后面添加L/l
        建议使用大写L,因为小写l和1傻傻分不清。
*/
public class IntTest02{
    public static void main(String[] args){

        // 分析这个代码存在类型转换吗,以下代码什么意思?
        // 不存在类型转换
        // 100 这个字面量被当做int类型处理
        // a变量是int类型,所以不存在类型的转换。
        // int类型的字面量赋值给int类型的变量。
        int a = 100;
        System.out.println(a);

        // 分析这个程序是否存在类型转换?
        // 分析:200这个字面量默认被当做int类型来处理
        // b变量是long类型,int类型占4个字节,long类型占8个字节
        // 小容量可以自动转换成大容量,这种操作被称为:自动类型转换。
        long b = 200;
        System.out.println(b);

        // 分析这个是否存在类型转换?
        // 这个不存在类型转换。
        // 在整数型字面量300后面添加一个L之后,300L联合起来就是一个long类型的字面量
        // c变量是long类型,long类型赋值给long类型不存在类型转换。
        long c = 300L;
        System.out.println(c);

        // 题目:
        // 可以吗?存在类型转换吗?
        // 2147483647默认被当做int来处理
        // d变量是long类型,小容量可以自动赋值给大容量,自动类型转换
        long d = 2147483647; // 2147483647是int最大值。
        System.out.println(d);

        // 编译器会报错吗?为什么?
        // 在java中,整数型字面量一上来编译器就会将它看做int类型
        // 而2147483648已经超出了int的范围,所以在没有赋值之前就出错了。
        // 记住,不是e放不下2147483648,e是long类型,完全可以容纳2147483648
        // 只不过2147483648本身已经超出了int范围。
        // 错误: 整数太大
        //long e = 2147483648;

        // 怎么解决这个问题呢?
        long e = 2147483648L;
        System.out.println(e);

    }
}
复制代码
复制代码
/*
    1、小容量可以直接赋值给大容量,称为自动类型转换。

    2、大容量不能直接赋值给小容量,需要使用强制类型转换符进行强转。
    但需要注意的是:加强制类型转换符之后,虽然编译通过了,但是运行
    的时候可能会损失精度。
*/
public class IntTest03{
    public static void main(String[] args){
        
        // 不存在类型转换
        // 100L是long类型字面量,x是long类型字面量。
        long x = 100L;

        // x是long类型,占用8个字节,而y变量是int类型,占用4个字节
        // 在java语言中,大容量可以“直接”赋值给小容量吗?不允许,没有这种语法。
        // 编译错误信息:错误: 不兼容的类型: 从long转换到int可能会有损失
        //int y = x;

        // 大容量转换成小容量,要想编译通过,必须加强制类型转换符,进行强制类型转换。
        // 底层是怎么进行强制类型转换的呢?
        // long类型100L:00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
        // 以上的long类型100L强转为int类型,会自动将“前面”的4个字节砍掉:00000000 00000000 00000000 01100100
        int y = (int)x; // 这个(int)就是强制类型转换符,加上去就能编译通过。
                             // 但是要记住:编译虽然过了,但是运行时可能损失精度。
        System.out.println(y); // 100


        // 定义变量a int类型,赋值100
        int a = 100;
        System.out.println(a);

        int b = a; // 将变量a中保存的值100复制一份给b变量。
        System.out.println(b);

    }
}
复制代码
复制代码
/*
    java中有一个语法规则:
        当这个整数型字面量没有超出byte的取值范围,那么这个
        整数型字面量可以直接赋值给byte类型的变量。
    
    这种语法机制是为了方便写代码,而存在的。
*/
public class IntTest04{
    public static void main(String[] args){
        // 分析:以下代码编译可以通过吗?
        // 300 被默认当做int类型
        // b变量是byte类型
        // 大容量转换成小容量,要想编译通过,必须使用强制类型转换符
        // 错误: 不兼容的类型: 从int转换到byte可能会有损失
        //byte b = 300;

        // 要想让以上的程序编译通过,必须加强制类型转换符
        // 虽然编译通过了,但是可能精度损失。
        // 300这个int类型对应的二进制:00000000 00000000 00000001 00101100
        // byte占用1个字节,砍掉前3个字节,结果是:00101100 (44)
        byte b = (byte)300;
        System.out.println(b); // 44

        // 这个编译能通过吗?
        // 1是int类型,默认被当做int类型来看。
        // x是byte类型,1个字节,大容量无法直接转换成小容量。
        // 按说是编译报错的。
        byte x = 1;
        byte y = 127;
        // 错误: 不兼容的类型: 从int转换到byte可能会有损失
        byte z = 128;

        // 当整数型字面量没有超出short类型取值范围的时候,该字面量可以直接赋值给short
        // 类型的变量。
        short s = 1;
        short s1 = 32767;
        // 错误: 不兼容的类型: 从int转换到short可能会有损失
        //short s2 = 32768;
        System.out.println(s);

    }
}
复制代码
复制代码
/*
    1、计算机在任何情况下都只能识别二进制
    2、计算机在底层存储数据的时候,一律存储的是“二进制的补码形式”
        计算机采用补码形式存储数据的原因是:补码形式效率最高。
    3、什么是补码呢?
        实际上是这样的,二进制有:原码 反码 补码 
    4、记住:
        对于一个正数来说:二进制原码、反码、补码是同一个,完全相同。
            int i = 1;
            对应的二进制原码:00000000 00000000 00000000 00000001
            对应的二进制反码:00000000 00000000 00000000 00000001
            对应的二进制补码:00000000 00000000 00000000 00000001
        对于一个负数来说:二进制原码、反码、补码是什么关系呢?
            byte i = -1;
            对应的二进制原码:10000001
            对应的二进制反码(符号位不变,其它位取反):11111110
            对应的二进制补码(反码+1):11111111
    5、分析 byte b = (byte)150;
        这个b是多少?
            int类型的4个字节的150的二进制码是什么?
                00000000 00000000 00000000 10010110
            将以上的int类型强制类型转为1个字节的byte,最终在计算机中的二进制码是:
                10010110
        
        千万要注意:计算机永远存储的都是二进制补码形式。也就是说上面
        10010110 这个是一个二进制补码形式,你可以采用逆推导的方式推算出
        这个二进制补码对应的原码是啥!!!!!!
            10010110 ---> 二进制补码形式
            10010101 ---> 二进制反码形式
            11101010 ---> 二进制原码形式 
*/
public class IntTest05{
    public static void main(String[] args){

        // 编译报错:因为150已经超出了byte取值范围,不能直接赋值,需要强转
        //byte b = 150;
        byte b = (byte)150;

        // 这个结果会输出多少呢?
        System.out.println(b); // -106
    }
}
复制代码
复制代码
/*
    结论:byte、char、short做混合运算的时候,各自先转换成int再做运算。
*/
public class IntTest06{
    public static void main(String[] args){

        char c1 = 'a';
        byte b = 1;

        // 注意:这里的"+"是负责求和的
        System.out.println(c1 + b); // 98

        // 错误: 不兼容的类型: 从int转换到short可能会有损失
        //short s = c1 + b; // 编译器不知道这个加法最后的结果是多少。只知道是int类型。

        // 这样修改行吗?
        //错误: 不兼容的类型: 从int转换到short可能会有损失
        //short s = (short)c1 + b;

        short s = (short)(c1 + b);

        //short k = 98;

        int a = 1;
        //错误: 不兼容的类型: 从int转换到short可能会有损失
        // short x = 1; 可以
        short x = a; // 不可以,编译器只知道a是int类型,不知道a中存储的是哪个值。
        System.out.println(x);
    }
}
复制代码
复制代码
/*
    结论:多种数据类型做混合运算的时候,最终的结果类型是“最大容量”对应的类型。

    char+short+byte 这个除外。
    因为char + short + byte混合运算的时候,会各自先转换成int再做运算。
*/
public class IntTest07{
    public static void main(String[] args){
        
        long a = 10L;
        char c = 'a';
        short s = 100;
        int i = 30;

        // 求和
        System.out.println(a + c + s + i); //237

        // 错误: 不兼容的类型: 从long转换到int可能会有损失
        // 计算结果是long类型
        //int x = a + c + s + i;

        int x = (int)(a + c + s + i);
        System.out.println(x);

        // 以下程序执行结果是?
        // java中规定,int类型和int类型最终的结果还是int类型。
        int temp = 10 / 3; // / 是除号。(最终取整)
        System.out.println(temp); // 3.33333吗?结果是:3

        // 在java中计算结果不一定是精确的。
        int temp2 = 1 / 2;
        System.out.println(temp2); // 0

    }
}
复制代码
复制代码
public class TypeTransferTest{
    public static void main(String[] args){
        // 编译报错,因为1000已经超出范围了。
        //byte b1 = 1000;
        // 可以
        byte b2 = 20;
        // 可以
        short s = 1000;
        // 可以
        int c = 1000;
        // 可以
        long d = c;
        // 编译报错
        //int e = d;
        // 可以
        int f = 10 / 3;
        // 可以
        long g = 10;
        // 编译报错
        //int h = g / 3;
        // 可以
        long m = g / 3;
        // 编译报错
        //byte x = (byte)g / 3;
        // 可以
        short y = (short)(g / 3);
        // 可以
        short i = 10;
        // 可以
        byte j = 5;
        // 编译报错
        //short k = i + j;
        // 可以
        int n = i + j;
        // 可以
        char cc = 'a';
        System.out.println(cc); // a
        System.out.println((byte)cc); // 97
        // cc 会先自动转换成int类型,再做运算
        int o = cc + 100;
        System.out.println(o); // 197
    }
}
复制代码

 

 

 

 

day07课堂笔记

1、关于数据类型详解
字符型:char
整数型:byte short int long
byte b = 127; // 可以直接赋值
short s = 32767; // 可以直接赋值
char // 没有超出char的取值范围可以直接赋值给char变量吗?


浮点型:float double
布尔型:boolean

2、综合的看一下,在类型转换的时候需要遵循哪些规则?

第一条:八种基本数据类型中,除 boolean 类型不能转换,剩下七种类型之间都可以
进行转换;

第二条:如果整数型字面量没有超出 byte,short,char 的取值范围,可以直接将其赋
值给byte,short,char 类型的变量;

第三条:小容量向大容量转换称为自动类型转换,容量从小到大的排序为:
byte < short(char) < int < long < float < double,其中 short和 char
都占用两个字节,但是char 可以表示更大的正整数;

第四条:大容量转换成小容量,称为强制类型转换,编写时必须添加“强制类型转换符”,
但运行时可能出现精度损失,谨慎使用;

第五条:byte,short,char 类型混合运算时,先各自转换成 int 类型再做运算;

第六条:多种数据类型混合运算,各自先转换成容量最大的那一种再做运算;

所有的笔试题都超不出以上的6条规则。死记硬背。

3、运算符

算术运算符:
+ - * / % ++ --

关系运算符:
> >= < <= == !=

逻辑运算符:
& | ! && ||

赋值运算符:
= += -= *= /= %=

三目运算符:
布尔表达式 ? 表达式1 : 表达式2

字符串连接运算符:
+

 

复制代码
/*
    算术运算符:
        +    求和
        -    相减
        *  乘积
        /  商
        %  求余数(求模)

        ++ 自加1
        -- 自减1
    
    对于++运算符来说:
        可以出现在变量前,也可以出现在变量后。
        不管出现在变量前还是后,总之++执行结束之后,变量的值一定会自加1。
    
*/
public class OperatorTest01{
    public static void main(String[] rags){
        int a = 10;
        int b = 3;
        System.out.println(a + b); // 13
        System.out.println(a - b); // 7
        System.out.println(a * b); // 30
        System.out.println(a / b); // 3
        System.out.println(a % b); // 1

        // 重点掌握 ++ 和 --
        // 这里重点讲解 ++,至于-- 大家可以照葫芦画瓢。
        // ++ 自加1(++可以出现在变量前,也可以出现在变量后。)
        int i = 10;

        // i变量自加1
        i++;

        System.out.println(i); //11

        int k = 10;
        // k变量自加1
        ++k;
        System.out.println(k); //11

        // 研究:++出现在变量前和变量后有什么区别?
        // 先看++出现在变量后。
        // 语法:当++出现在变量后,会先做赋值运算,再自加1
        int m = 20;
        int n = m++;
        System.out.println(n); // 20
        System.out.println(m); // 21

        // ++出现在变量前呢?
        // 语法规则:当++出现在变量前的时候,会先进行自加1的运算,然后再赋值。
        int x = 100;
        int y = ++x;
        System.out.println(x); // 101
        System.out.println(y); // 101

        // 题目
        int c = 90;
        System.out.println(c++);  // 传,这个“传”在这里有一个隐形的赋值运算。90
        // 把上面代码拆解开
        //int temp = c++;
        //System.out.println(temp);

        System.out.println(c); // 91

        int d = 80;
        System.out.println(++d); //81
        // 拆解
        //int temp2 = ++d;
        //System.out.println(temp2);

        System.out.println(d); // 81

        /*
        int e = 1;
        int f = e; // e赋值给f,表示将e“传”给了f
        */

        // 自己测试以下 -- 运算符。

    }
}
复制代码

 

复制代码
/*
    关系运算符:
        >
        >=
        <
        <=
        ==
        !=

        一定要记住一个规则:
            所有的关系运算符的运算结果都是布尔类型,
            不是true就是false,不可能是其他值。
        
        在java语言中:
            = : 赋值运算符
            == :关系运算符,判断是否相等。
        
        注意:关系运算符中如果有两个符号的话,两个符号之间不能有空格。
            >= 这是对的, > = 这是不对的。
            == 这是对的,= = 这是不对的。
*/
public class OperatorTest02{
    public static void main(String[] args){
        int a = 10;
        int b = 10;
        System.out.println(a > b); // false
        System.out.println(a >= b); // true
        System.out.println(a < b); // false
        System.out.println(a <= b); // true
        System.out.println(a == b); // true
        System.out.println(a != b); // false
    }
}
复制代码
复制代码
/*
    逻辑运算符:
        &    逻辑与(可以翻译成并且)
        |    逻辑或(可以翻译成或者)
        !    逻辑非(取反)
        &&    短路与
        ||    短路或
    
    用普通话描述的话:100 大于 99 并且 100 大于 98 ,有道理
    用代码描述的话:100 > 99 & 100 > 98 --> true

    true & true --> true

    非常重要:
        逻辑运算符两边要求都是布尔类型,并且最终的运算结果也是布尔类型。
        这是逻辑运算符的特点。
    
    100 & true 不行,语法错误。
    100 & 200 不行,没有这种语法。
    true & false 这样可以。

    100 > 90 & 100 > 101 --> false

    & 两边都是true,结果才是true
    | 有一边是true,结果就是true

*/    
public class OperatorTest03{
    public static void main(String[] args){
        // 对于逻辑与&运算符来说,只要有一边是false,结果就是false。
        // 只有两边同时为true,结果才是true。
        System.out.println(true & true); // true
        System.out.println(true & false); // false
        System.out.println(false & false); // false

        System.out.println(100 > 90 & 100 > 101); // false
        System.out.println((100 > 90) & (100 > 101)); // false

        int a = 100;
        int b = 101;
        int c = 90;
        System.out.println(a < b & a > c); // true

        // 对于逻辑或呢?
        // 只要有一边是true,结果就是true。
        System.out.println(a < b | c > b); // true
        System.out.println(true | false); // true

        System.out.println(true | true); // true
        System.out.println(false | false); // false

        System.out.println(!false); // true
        System.out.println(!true); // false

        // 注意:这里需要加一个小括号。
        System.out.println(!(a > b)); // true

        /*
            关于短路与 &&,短路或 ||
            其中重点学习短路与,短路或照葫芦画瓢。

            短路与&& 和 逻辑与 &有什么区别?
                首先这两个运算符的运算结果没有任何区别,完全相同。
                只不过“短路与&&”会发生短路现象。

            什么是短路现象呢?
                右边表达式不执行,这种现象叫做短路现象。

            什么时候使用&&,什么时候使用& ?
                从效率方面来说,&&比&的效率高一些。
                因为逻辑与&不管第一个表达式结果是什么,第二个表达式一定会执行。

                以后的开发中,短路与&&和逻辑与还是需要同时并存的。
                    大部分情况下都建议使用短路与&&
                    只有当既需要左边表达式执行,又需要右边表达式执行的时候,才会
                    选择逻辑与&。
        */

        System.out.println(true & true); // true
        System.out.println(true & false); // false
        System.out.println(false & false); // false

        System.out.println(true && true); // true
        System.out.println(true && false); // false
        System.out.println(false && false); // false

        // 接下来需要理解一下什么是短路现象,什么时候会发生“短路”。
        int x = 10;
        int y = 11;
        // 逻辑与&什么时候结果为true(两边都是true,结果才是true)
        // 左边的 x>y 表达式结果已经是false了,其实整个表达式的结
        // 果已经确定是false了,按道理来说右边的表达式不应该执行。
        System.out.println(x > y & x > y++); 

        // 通过这个测试得出:x > y++ 这个表达式执行了。
        System.out.println(y); // 12

        //测试短路与&&
        int m = 10;
        int n = 11;
        // 使用短路与&&的时候,当左边的表达式为false的时候,右边的表达式不执行
        // 这种现象被称为短路。
        System.out.println(m > n && m > n++);
        System.out.println(n); // 11

        // 问题:什么时候发生短路或现象?
        // || 短路或
        // “或”的时候只要有一边是true,结果就是true。
        // 所以,当左边的表达式结果是true的时候,右边的表达式不需要执行,此时会短路。

    }
}
复制代码
复制代码
/*
    赋值运算符:
        1、赋值运算符包括“基本赋值运算符”和“扩展赋值运算符”:基本的、扩展的。
        2、基本赋值运算符?
            =
        3、扩展的赋值运算符?
            +=
            -=
            *=
            /=
            %=
            注意:扩展赋值运算符在编写的时候,两个符号之间不能有空格。
                + =  错误的。
                += 正确的。
        4、很重要的语法机制:
            使用扩展赋值运算符的时候,永远都不会改变运算结果类型。
            byte x = 100;
            x += 1;
            x自诞生以来是byte类型,那么x变量的类型永远都是byte。不会变。
            不管后面是多大的数字。
*/
public class OperatorTest04{
    public static void main(String[] args){

        // 赋值运算符“=”右边优先级比较高,先执行右边的表达式
        // 然后将表达式执行结束的结果放到左边的“盒子”当中。(赋值)
        int i = 10;
        // 重新赋值
        i = 20;

        byte b = 10;
        b = 20;

        /*
            以 += 运算符作为代表,学习扩展赋值运算符。
            其它的运算符,例如:-= *= /= %= 和 += 原理相似。
        */
        int k = 10;
        k += 20; // k变量追加20
        System.out.println(k); // 30

        int m = 10;
        // += 运算符类似于下面的表达式
        m = m + 20;
        System.out.println(m); // 30

        // 研究:
        // i += 10 和 i = i + 10 真的是完全一样吗?
        // 答案:不一样,只能说相似,其实本质上并不是完全相同。
        byte x = 100; // 100没有超出byte类型取值范围,可以直接赋值
        System.out.println(x); // 100

        // 分析:这个代码是否能够编译通过?
        // 错误: 不兼容的类型: 从int转换到byte可能会有损失
        //x = x + 1; // 编译器检测到x + 1是int类型,int类型可以直接赋值给byte类型的变量x吗?

        // 使用扩展赋值运算符可以吗?
        // 可以的,所以得出结论:x += 1 和 x = x + 1不一样。
        // 其实 x += 1 等同于:x = (byte)(x + 1);
        x += 1;
        System.out.println(x); // 101

        // 早就超出byte的取值范围了。
        x += 199; // x = (byte)(x + 199);
        System.out.println(x); // 44 (当然会自动损失精度了。)

        int y = 100;
        y += 100;
        System.out.println(y); // 200

        y -= 100; // x = x - 100;
        System.out.println(y); // 100

        y *= 10; // x = x * 10;
        System.out.println(y); // 1000

        y /= 30; // x = x / 30;
        System.out.println(y); // 33

        y %= 10; // x = x % 10;
        System.out.println(y); // 3
        
    }
}
复制代码
复制代码
/*
    条件运算符:(三目运算符。)
        语法格式:
            布尔表达式 ? 表达式1 : 表达式2

        执行原理是什么?
            布尔表达式的结果为true时,表达式1的执行结果作为整个表达式的结果。
            布尔表达式的结果为false时,表达式2的执行结果作为整个表达式的结果。
*/
public class OperatorTest05{
    public static void main(String[] args){

        // 合法的java语句
        // 表示声明一个变量,起名i
        int i = 100;

        // 这里会编译出错吗?
        // 错误: 不是语句
        // 100;

        // 错误: 不是语句
        //'男';

        boolean sex = true;
        
        // 分析以下代码是否存在语法错误?
        // 错误: 不是语句
        //sex ? '男' : '女';

        // 前面的变量的c的类型不能随意编写。
        // 最终的计算结果是字符型,所以变量也需要使用char类型。
        char c = sex ? '男' : '女';
        System.out.println(c);

        // 实际开发中不会这样,故意的
        //错误: 不兼容的类型: 条件表达式中的类型错误
        //char x = sex ? '男' : "女";
        //System.out.println(x);

        // 这样可以吗?可以
        sex = false;
        System.out.println(sex ? '男' : "女");

        //System.out.println(这里很牛,因为这里什么类型的数据都能放);
        /*
        System.out.println(100);
        System.out.println("100");
        System.out.println('a');
        */
    }
}
复制代码
复制代码
/*
    + 运算符:
        1、+ 运算符在java语言中有两个作用。
            作用1:求和
            作用2:字符串拼接

        2、什么时候求和?什么时候进行字符串的拼接呢?
            当 + 运算符两边都是数字类型的时候,求和。
            当 + 运算符两边的“任意一边”是字符串类型,那么这个+会进行字符串拼接操作。

        3、一定要记住:字符串拼接完之后的结果还是一个字符串。
*/
public class OperatorTest06{

    public static void main(String[] args){

        // 定义一个年龄的变量。
        int nianLing = 35;

        // + 在这里会进行字符串的拼接操作。
        System.out.println("年龄=" + nianLing); // "年龄=35"

        int a = 100;
        int b = 200;
        // 这里的 + 两边都是数字,所以加法运算
        int c = a + b;
        System.out.println(c); // 300

        // 注意:当一个表达式当中有多个加号的时候
        // 遵循“自左向右”的顺序依次执行。(除非额外添加了小括号,小括号的优先级高)
        // 第一个+先运算,由于第一个+左右两边都是数字,所以会进行求和。
        // 求和之后结果是300,代码就变成了:System.out.println(300 + "110");
        // 那么这个时候,由于+的右边是字符串"110",所以此时的+会进行字符串拼接。
        System.out.println(a + b + "110"); // 最后一定是一个字符串:"300110"

        // 先执行小括号当中的程序:b + "110",这里的+会进行字符串的拼接,
        // 拼接之后的结果是:"200110",这个结果是一个字符串类型。
        // 代码就变成了:System.out.println(a + "200110");
        // 这个时候的+还是进行字符串的拼接。最终结果是:"100200110"
        System.out.println(a + (b + "110"));

        // 在控制台上输出"100+200=300"
        System.out.println("100+200=300"); // 不是这个意思。

        // 以下有效的运算符加号一共有4个,这4个加号都是字符串拼接操作。
        System.out.println(a + "+" + b + "=" + c);
        
        // 分析这个结果是多少?
        // 以下表达式中没有小括号,所以遵循自左向右的顺序依次执行。
        // 第1,2,3,4个加号都是进行字符串拼接,拼接之后的结果是:"100+200=100"
        // 前4个加号运行之后是一个字符串"100+200=100"
        // 然后这个字符串再和最后一个b变量进行字符串的拼接:"100+200=100200"
        System.out.println(a + "+" + b + "=" + a + b);

        // 和上面程序不一样的地方是:最后一个加号先执行,并且会先进行求和运算。
        System.out.println(a + "+" + b + "=" + (a + b));

        // 在java语言中怎么定义字符串类型的变量呢?
        // int是整数型 i 是变量名 10是字面量
        //int i = 10;
        // String是字符串类型,并且String类型不属于基本数据类型范畴,属于引用类型。
        // name是变量名,只要是合法的标识符就行。
        // "jack" 是一个字符串型字面量。
        String name = "李四"; // String类型是字符串类型,其中S是大写,不是:string

        // 错误:类型不兼容。
        //String name = 100;

        // 会进行字符串的拼接
        //System.out.println("登录成功欢迎" + name + "回来");
        
        
        // 口诀:加一个双引号"",然后双引号之间加两个加号:"++",然后两个加号中间加变量名:"+name+"
        System.out.println("登录成功欢迎"+name+"回来");

        System.out.println(a + "+" + b + "=" + c);

    }
}
复制代码
复制代码
// 大家讨论最多的一个问题。
// 如果只是针对于面试题的话,建议死记硬背。
public class Homework01{
    public static void main(String[] args){
        int i = 10;
        i = i++;
        // 大部分同学都会认为这个i一定是11
        // 这个i变量最终的结果是10(惊讶)
        // 首先,第一点:这种代码以后不会有人写。
        // 其次:第二点:没必要讨论这个问题,因为在C++中运行结果确实是11.
        // java中运行结果是10
        // c++中运行结果是11
        // 为什么?因为java和c++的编译器是不同的人开发的。原理不同。
        System.out.println(i);
        
        // 在java语言中i++,这种表达式在执行的时候,会提前先将i变量找一个临时
        // 变量存储一下。(C++中并没有这样做。)
        /*
        int k = 10;
        k = k++;
        */
        int k = 10;
        // k = k++;对应的是下面三行代码
        int temp = k;
        k++;
        k = temp;
        System.out.println(k);
    }
}
复制代码
复制代码
public class Homework02{
    public static void main(String[] args){
        int x = 10;
        int a = x + x++; // 该行代码只要结束,x就是11
        System.out.println("a =" + a); // 20 (x走到这里就变成11了)
        System.out.println("x =" + x); // 11
        int b = x + ++x; // 23 该行代码结束之后,x就是12
        System.out.println("b =" + b); // 23
        System.out.println("x =" + x); // 12
        int c = x + x--; // 该行代码执行结束之后,x就是11
        System.out.println("c =" + c); // 24
        System.out.println("x =" + x); // 11
        int d = x + --x; // 该行代码只要执行结束,x就是10了。
        System.out.println("d =" + d); // 21
        System.out.println("x =" + x); // 10
    }
}
复制代码
复制代码
public class Homework03{
    public static void main(String[] args){
        int i = 5;
        int j = 5;
        int m = 5;
        int n = 5;
        i++; // 这行代码执行结束之后,i是6
        j = j + 1; // 这行代码执行结束之后,j是6
        m--; // 这行代码执行结束之后,m是4
        n = n - 1; // 这行代码执行结束之后,n是4
        System.out.println(i); // 6
        System.out.println(i++); // 6(虽然输出结果是6,但是你别忘了这行代码执行结束之后i就是7了。)
        System.out.println(++i); // 8(这行代码执行结束之后,i本身的值变成了8)
        System.out.println(i--); // 8(这行代码执行结束之后,i本身的值变成了7)
        System.out.println(); // 小括号中什么也没有,空白,表示换行
        System.out.println(j);
        System.out.println(j++);
        System.out.println(j--);
        System.out.println(--j);
        System.out.println();
        System.out.println(m);
        System.out.println(n);
    }
}
复制代码

 

 

 

 

 

day08课堂笔记

1、怎么接收用户键盘输入?
java.util.Scanner s = new java.util.Scanner(System.in);
// 接收整数
int i = s.nextInt()
// 接收字符串
String str = s.next();

 

复制代码
/*
1、输出信息到控制台:
    System.out.println(...);
2、在java中怎么接收键盘的输入呢?
    先声明一下,这个代码看不懂很正常,因为这个代码是面向对象章节学习之后才能够理解。
    这个代码以后复制粘贴就行。

    前提:java.util.Scanner s = new java.util.Scanner(System.in); 
    接收一个整数怎么办?
        int num = s.nextInt();
        
    接收一个字符串怎么办?
        String str = s.next();
*/
public class KeyInput{
    public static void main(String[] args){

        // 创建一个键盘扫描器对象
        // s 变量名,可以修改。其它不能改。 
        java.util.Scanner s = new java.util.Scanner(System.in); //这行代码写一次就行了。

        // 接收用户的输入,从键盘上接收一个int类型的数据
        // 解释这行代码,尽量让大家明白:代码执行到这里的时候,会暂停下来
        // 等待用户的输入,用户可以从键盘上输入一个整数,然后回车,回车之后
        // i变量就有值了。并且i变量中保存的这个值是用户输入的数字。
        // i变量就是接收键盘数据的。
        int i = s.nextInt(); // i是变量名,s是上面的变量名
        System.out.println("您输入的数字是:" + i);

        // 代码执行到此处又会停下来,等待用户的输入。
        // 敲完回车,s.nextInt();代码执行结束。
        int j = s.nextInt();
        System.out.println("您输入的数字是:" + j);

        // 如果输入的不是数字,那么会出异常:InputMismatchException
        int m = s.nextInt();
        System.out.println("您输入的数字是:" + m);

        // 我怎么从键盘上接收一个字符串呢?
        // 程序执行到此处会停下来,等待用户的输入,用户可以输入字符串。
        String str = s.next();
        System.out.println("您输入了:" + str);

        // 完整的。
        System.out.print("请输入用户名:");
        String name = s.next();
        System.out.println("欢迎"+name+"回来");
    }
}
复制代码

 

复制代码
import java.util.Scanner;

// 更有交互性
public class KeyInput2{
    public static void main(String[] args){
        // 创建键盘扫描器对象
        Scanner s = new Scanner(System.in);
        // 输出一个欢迎信息
        System.out.println("欢迎使用小型迷你计算器");
        System.out.print("请输入第1个数字:");
        int num1 = s.nextInt();
        System.out.print("请输入第2个数字:");
        int num2 = s.nextInt();
        System.out.println(num1 + "+" + num2 + "=" + (num1 + num2));
    }
}
复制代码

 

 

2、控制语句
2.1、控制语句的出现可以让我们的程序具有逻辑性/条理性,可以使用控制语句
来实现一个“业务”了。

2.2、控制语句包括几类?
3类:
选择语句
循环语句
转向语句

2.3、选择语句也可以叫做分支语句
if语句
switch语句

复制代码
/*
    if语句的语法结构以及运行原理?
        if语句是分支语句,也可以叫做条件语句。
        if语句的语法格式:
            第一种写法:
                int a = 100;
                int b = 200;
                if(布尔表达式){
                    java语句;
                    java语句;
                }
                这里的一个大括号{} 叫做一个分支。
                if 这个单词翻译为如果,所以又叫做条件语句。
                该语法的执行原理是:
                    如果布尔表达式的结果是true,则执行大括
                    号中的程序,否则大括号中代码不执行。

            第二种写法:
                if(布尔表达式){  // 分支1
                    java语句;     
                }else{            // 分支2
                    java语句;
                }
                执行原理:如果布尔表达式的结果是true,则执行
                分支1,分支2不执行。如果布尔表达式的结果是false,
                分支1不执行,执行分支2.
                以上的这个语句可以保证一定会有一个分支执行。
                else表示其它。
            
            第三种写法:
                if(布尔表达式1){ // 分支1
                    java语句;
                }else if(布尔表达式2){ // 分支2
                    java语句;
                }else if(布尔表达式3){
                    java语句;
                }else if(布尔表达式4){
                    java语句;
                }....
                以上if语句的执行原理?
                    先判断“布尔表达式1”,如果“布尔表达式1”为true,则执行分支1,
                    然后if语句结束了。
                    当“布尔表达式1”结果是false,那么会继续判断布尔表达式2的结果,
                    如果布尔表达式2的结果是true,则执行分支2,然后整个if就结束了。

                    从上往下依次判断,主要看第一个true发生在哪个分支上。
                    第一个true对应的分支执行,只要一个分支执行,整个if结束。
            
            第四种写法:
                if(布尔表达式1){ // 分支1
                    java语句;
                }else if(布尔表达式2){ // 分支2
                    java语句;
                }else if(布尔表达式3){
                    java语句;
                }else if(布尔表达式4){
                    java语句;
                }else{
                    java语句; // 以上条件没有一个成立的。这个else就执行了。
                }

        
        注意:
            1、对于if语句来说,在任何情况下只能有1个分支执行,不可能
                存在2个或者更多个分支执行。if语句中只要有1个分支执行了,
                整个if语句就结束了。(对于1个完整的if语句来说的。)
            
            2、以上4种语法机制中,凡是带有else分支的,一定可以保证会有
            一个分支执行。以上4种当中,第一种和第三种没有else分支,这样
            的语句可能会导致最后一个分支都不执行。第二种和第四种肯定会有
            1个分支执行。

            3、当分支当中“java语句;”只有1条,那么大括号{}可以省略,但为了
            可读性,最好不要省略。(有的程序员在编写代码的时候,可能会故意
            将大括号{}省略,你能看懂就行。)

            4、控制语句和控制语句之间是可以嵌套的,但是嵌套的时候大家最好
            一个语句一个语句进行分析,不要冗杂在一起分析。
                if(true){
                    //窍门:分析外面if语句的时候,里面的这个if语句可以看做是普通的一堆java代码。
                    if(true){
                        if(false){
                        
                        }else{
                            ....最终走这里了。
                        }
                    }else{
                    
                    }
                }else{
                
                }

                if(){
                    // 窍门:分析外面if时,里面的for循环当做普通java代码来看。
                    for(){
                        if(){
                            for(){
                            
                            }
                        }
                    }
                }else{
                    while(){
                        if(){
                            for(){
                            
                            }
                        }
                    }
                }

*/
public class IfTest01{
    public static void main(String[] args){

        // 定义一个布尔类型的变量,表示性别。
        //boolean sex = true;
        boolean sex = false;

        //业务:当sex为true时表示男,为false时表示女。
        /*
        if(sex == true){ // == 是关系运算符,不是赋值运算符,== 双等号是用来判断是否相等的。
            System.out.println("男");
        }else{
            System.out.println("女");
        }
        */

        // 改良。
        sex = true;
        if(sex){
            System.out.println("男");
        }else{
            System.out.println("女");
        }

        // 可以再进一步改良
        // 可以使用三目运算符
        sex = false;
        System.out.println(sex ? "男" : "女");

        // 代码可以这样写吗?
        // ()小括号当中最终取的值是sex变量的值。
        // 而sex是布尔类型,所以这个可以通过。
        sex = false;
        if(sex = true){ // 以前sex不管是true还是false,走到这一行sex一定是true。
            System.out.println("男"); // 输出"男"
        }else{
            // 虽然这种语法可以,但是会导致else分支永远不能执行。
            System.out.println("女");
        }

        int i = 100;
        if(i == 100){
            System.out.println("i是100");
        }

        /*
        //错误: 不兼容的类型: int无法转换为boolean
        if(i = 100){ // (i = 100)整体执行完之后是一个int类型,不是布尔类型。
            System.out.println("i是100");
        }
        */

        // 当分支中只有一条java语句的话,大括号可以省略。
        if(sex) 
            System.out.println("男"); 
        else 
            System.out.println("女");
        
        
        // 判断以下程序会出现问题吗?会出什么问题?第几行代码报错????
        if(sex)
            System.out.println("男");
            System.out.println("HelloWorld!"); // 以上的这3行代码没有问题,合乎语法。
        /*
        else // 这一行编译报错,因为else缺少if
            System.out.println("女");
        */
        

    }
}
复制代码
复制代码
/*
    业务要求:
        1、从键盘上接收一个人的年龄。
        2、年龄要求为[0-150],其它值表示非法,需要提示非法信息。
        3、根据人的年龄来动态的判断这个人属于生命的哪个阶段?
            [0-5] 婴幼儿
            [6-10] 少儿
            [11-18] 少年
            [19-35] 青年
            [36-55] 中年
            [56-150] 老年
        4、请使用if语句完成以上的业务逻辑。
*/
public class IfTest02{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入年龄:");
        int age = s.nextInt();
        //System.out.println("测试以下,您输入的年龄是:" + age);
        /*
        if(age < 0 || age > 150){
            System.out.println("对不起,年龄值不合法");
        } else {
            // 能够走到这个分支当中,说明年龄是合法的。
            // 可以进一步使用嵌套的if语句进行判断。
            //if(age >= 0 && age <= 5){}
            // 当前先使用if嵌套的方式,当然,嵌套不是必须的。可以有其它写法。
            //System.out.println("年龄值合法");
            // 年龄值合法的情况下,继续判断年龄属于哪个阶段的!!!!
            //if(age >= 0 && age <= 5){} // 这样写代码比较啰嗦了。
            if(age <= 5){
                System.out.println("婴幼儿");
            } else if(age <= 10){
                System.out.println("少儿");
            } else if(age <= 18){
                System.out.println("少年");
            } else if(age <= 35){
                System.out.println("青年");
            } else if(age <= 55){
                System.out.println("中年");
            } else {
                System.out.println("老年");
            }
        }
        */

        // 可以不嵌套吗?可以
        /*
        if(age < 0 || age > 150){
            System.out.println("对不起,年龄值不合法");
        } else if(age <= 5){
            System.out.println("婴幼儿");
        } else if(age <= 10){
            System.out.println("少儿");
        } else if(age <= 18){
            System.out.println("少年");
        } else if(age <= 35){
            System.out.println("青年");
        } else if(age <= 55){
            System.out.println("中年");
        } else {
            System.out.println("老年");
        }
        */

        // 进一步改良
        String str = "老年"; // 字符串变量默认值是“老年”
        if(age < 0 || age > 150){
            System.out.println("对不起,年龄值不合法");
            // 既然不合法,你就别让程序往下继续执行了,怎么终止程序执行
            //return;
        } else if(age <= 5){
            str = "婴幼儿";
        } else if(age <= 10){
            str = "少儿";
        } else if(age <= 18){
            str = "少年";
        } else if(age <= 35){
            str = "青年";
        } else if(age <= 55){
            str = "中年";
        } 
        System.out.println(str);
    
        // 对于初学者来说可能代码会写成这样,这是正常的。
        // 代码的经验需要一步一步的积累,慢慢的代码就会越来越漂亮了。
        // 需要时间,需要积累代码经验。最好的代码是:最少的代码量,最高的效率。
        /*
        if(age >= 0 && age <= 5){
        
        }else if(age >= 6 && age <= 10){
        
        }else if.....
        */

    }
}
复制代码
复制代码
/*
    题目:
        1、系统接收一个学生的考试成绩,根据考试成绩输出成绩的等级。

        2、等级:
            优:[90~100]
            良:[80~90) 
            中:[70-80)
            及格:[60~70)
            不及格:[0-60)

        3、要求成绩是一个合法的数字,成绩必须在[0-100]之间,成绩可能带有小数。
*/
public class IfTest03{
    public static void main(String[] args){
        // 键盘扫描器对象
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入您的考试成绩:");
        // 考试成绩带有小数
        double score = s.nextDouble(); //程序到这里停下了,等待用户的输入。
        // 判断考试成绩
        String str = "优";
        if(score < 0 || score > 100){
            str = "成绩不合法!!!";
        }else if(score < 60){
            str = "不及格";
        }else if(score < 70){
            str = "及格";
        }else if(score < 80){
            str = "中";
        }else if(score < 90){
            str = "良";
        }
        System.out.println(str);
    }
}
复制代码
复制代码
/*
    题目:
        业务:
            从键盘上接收天气的信息:
                1表示:雨天
                0表示:晴天
            同时从键盘上接收性别的信息:
                1表示:男
                0表示:女
            业务要求:
                当天气是雨天的时候:
                    男的:打一把大黑伞
                    女的:打一把小花伞
                当天气是晴天的时候:
                    男的:直接走起,出去玩耍
                    女的:擦点防晒霜,出去玩耍
        
        需要使用if语句以及嵌套的方式展现这个业务。

        可以在程序的开始,接收两个数据,一个数据是天气,一个数据是性别。
        然后将这两个数据保存到变量中。
*/
public class IfTest04{
    public static void main(String[] args){
        // 接收用户键盘输入
        java.util.Scanner s = new java.util.Scanner(System.in);
        // 提示信息
        System.out.print("请输入您的性别,输入1表示男,输入0表示女:");
        // 程序停下来等待用户的输入
        int gender = s.nextInt();
        //System.out.println(gender);
        // 提示信息
        System.out.print("请输入当前的天气,1表示雨天,0表示晴天:");
        // 等待用户的输入
        int weather = s.nextInt();
        // 开发要不断的进行测试,不要期望一次把程序写好。
        //System.out.println(weather);
        if(weather == 1){
            //System.out.println("雨天");
            if(gender == 1){
                //
                System.out.println("下雨了,小哥哥,出门的时候记得拿一把大黑伞哦!");
            }else if(gender == 0){
                //
                System.out.println("下雨了,小姐姐,出门的时候记得带一把小花伞哦!");
            }
        }else if(weather == 0){
            //System.out.println("晴天");
            if(gender == 1){
                //
                System.out.println("外面的天气不错,老铁们出去玩耍吧!");
            }else if(gender == 0){
                //
                System.out.println("外面的天气晴朗,小姐姐要保护好皮肤哦,擦点防晒霜!");
            }
        }
    }
}
复制代码
复制代码
/*
    switch语句:
        1、switch语句也是选择语句,也可以叫做分支语句。
        2、switch语句的语法格式

            switch(值){
            case 值1:
                java语句;
                java语句;...
                break;
            case 值2:
                java语句;
                java语句;...
                break;
            case 值3:
                java语句;
                java语句;...
                break;
            default:
                java语句;
            }

            以上是一个完整的switch语句:
                其中:break;语句不是必须的。default分支也不是必须的。

            switch语句支持的值有哪些?
                支持int类型以及String类型。
                但一定要注意JDK的版本,JDK8之前不支持String类型,只支持int。
                在JDK8之后,switch语句开始支持字符串String类型。

                switch语句本质上是只支持int和String,但是byte,short,char也可以
                使用在switch语句当中,因为byte short char可以进行自动类型转换。

                switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较。

        3、switch语句的执行原理
            拿“值”与“值1”进行比较,如果相同,则执行该分支中的java语句,
            然后遇到"break;"语句,switch语句就结束了。

            如果“值”与“值1”不相等,会继续拿“值”与“值2”进行比较,如果相同,
            则执行该分支中的java语句,然后遇到break;语句,switch结束。

            注意:如果分支执行了,但是分支最后没有“break;”,此时会发生case
            穿透现象。

            所有的case都没有匹配成功,那么最后default分支会执行。
*/
public class SwitchTest01{
    public static void main(String[] args){
        
        // 分析这个程序是否能够编译通过?
        // switch只支持int和String类型。
        // 错误: 不兼容的类型: 从long转换到int可能会有损失
        /*
        long x = 100L;
        switch(x){
        
        }
        */

        /*
        long x = 100L;
        switch((int)x){
        
        }
        */
        
        /*
        byte b = 100;
        switch(b){
        
        }
        */

        /*
        short s = 100;
        switch(s){
        
        }
        */

        /*
        char c = 'a';
        switch(c){
        
        }
        */

        //switch也支持字符串String类型。
        //switch("abc"){}

        // 写一个完整的switch语句
        // 接收键盘输入,根据输入的数字来判断星期几。
        // 0 星期日
        // 1 星期一
        // ....
        // 假设输入的数字就是正确的。0到6
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入[0-6]的整数:");
        int num = s.nextInt();

        /*
        switch(num){
        case 0:
            System.out.println("星期日");
            break;
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
        }
        */

        //case穿透现象
        /*
        switch(num){
        case 0:
            System.out.println("星期日");
            break;
        case 1:
            System.out.println("星期一");
        case 2:
            System.out.println("星期二");
        case 3:
            System.out.println("星期三");
        case 4:
            System.out.println("星期四");
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
        }
        */

        // 关于default语句,当所有的case都没有匹配上的时候,执行default语句。
        /*
        switch(num){
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        default:
            System.out.println("星期日");
        }
        */

        // 关于case合并的问题
        switch(num){
        case 1: case 2: case 3:
            System.out.println("星期一");
            break;
        case 4:
            System.out.println("星期二");
            break;
        case 5:
            System.out.println("星期三");
            break;
        case 6:
            System.out.println("星期四");
            break;
        case 7:
            System.out.println("星期五");
            break;
        case 8:
            System.out.println("星期六");
            break;
        default:
            System.out.println("星期日");
        }


    }
}
复制代码
复制代码
/*
题目:
        1、系统接收一个学生的考试成绩,根据考试成绩输出成绩的等级。

        2、等级:
            优:[90~100]
            良:[80~90) 
            中:[70-80)
            及格:[60~70)
            不及格:[0-60)

        3、要求成绩是一个合法的数字,成绩必须在[0-100]之间,成绩可能带有小数。

        必须使用switch语句来完成,你该怎么办?
*/
public class SwitchTest02{
    public static void main(String[] args){
        // 提示用户输入学生成绩
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入学生成绩:");
        double score = s.nextDouble();
        //System.out.println(score);
        if(score < 0 || score > 100){
            System.out.println("您输入的学生成绩不合法,再见!");
            return; // 这个代码的执行,会让main结束。后面会讲。
        }

        // 程序能够执行到这里说明成绩一定是合法的。
        // grade的值可能是:0 1 2 3 4 5 6 7 8 9 10
        // 0 1 2 3 4 5 不及格
        // 6 及格
        // 7 中
        // 8 良
        // 9 10 优
        
        int grade = (int)(score / 10); // 95.5/10结果9.55,强转为int结果是9
        String str = "不及格";
        switch(grade){
        case 10: case 9:
            str = "优";
            break;
        case 8: 
            str = "良";
            break;
        case 7:
            str = "中";
            break;
        case 6:
            str = "及格";
        }
        System.out.println("该学生的成绩等级为:" + str);
    }
}
复制代码

 



2.4、循环语句:主要循环反复的去执行某段特定的代码块
for循环
while循环
do..while..循环

复制代码
// 演示一下:为什么要使用循环
// 循环语句的出现就是为了解决代码的复用性。
public class ForTest01{
    public static void main(String[] args){
        // 要求在控制台上输出100个100
        /*
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        System.out.println(100);
        */
        // .... 重复的代码太多了
        // 简化一下以上的代码,可以使用循环
        // 什么时候可以考虑使用循环呢?相同的代码重复出现的时候,可以使用循环语句。
        for(int i = 0; i < 100; i++){
            System.out.println(100);
        }
    }
}
复制代码
复制代码
/*
    1、for循环的语法机制以及运行原理?
        语法机制:
            for(初始化表达式; 条件表达式; 更新表达式){
                循环体; // 循环体由java语句构成
                java语句;
                java语句;
                java语句;
                java语句;
                ....
            }
            注意:
                第一:初始化表达式最先执行,并且在整个循环中只执行一次。
                第二:条件表达式结果必须是一个布尔类型,也就是:true或false
            执行原理:
                先执行初始化表达式,并且初始化表达式只执行1次。
                然后判断条件表达式的结果,如果条件表达式结果为true,
                则执行循环体。
                循环体结束之后,执行更新表达式。
                更新完之后,再判断条件表达式的结果,
                如果还是true,继续执行循环体。

                直到更新表达式执行结束之后,再次判断条件时,条件为false,
                for循环终止。
            
            更新表达式的作用是:控制循环的次数,换句话说,更新表达式会更新
            某个变量的值,这样条件表达式的结果才有可能从true变成false,从而
            终止for循环的执行,如果确实更新表达式,很有可能会导致死循环。

*/
public class ForTest02{
    public static void main(String[] args){
        // 最简练的for循环怎么写?
        // 初始化表达式、条件表达式、更新表达式 其实都不是必须的!!!
        /*
        for(;;){
            System.out.println("死循环");
        }
        */

        // 最常见的for循环
        // 循环10次,输出0~9
        /*
            i = 0
            i = 1
            i = 2
            i = 3
            i = 4
            i = 5
            i = 6
            i = 7
            i = 8
            i = 9

            强调一下:对于以下的这个for循环,其中int i = 0;
            最先执行,并且只执行一次,而且i变量属于for循环
            的局部变量,for循环结束之后i的内存就释放了。
            这个i变量只能在for循环中使用。
            这个i变量属于for循环域。在main方法中没有办法直接使用。
        */
        for(int i = 0;i < 10;i++){
            System.out.println("i = " + i); // 0 1 2 3....9
        }

        //错误: 找不到符号
        //System.out.println(i);

        // i变量的作用域就扩大了。
        int i = 0;
        for(;i < 10;i++){
            System.out.println("i --> " + i); // 0 1 2 3....9
        }
        System.out.println("这里的i可以访问吗?i = " + i); // 10

        // 变形
        for(int k = 1; k <= 10; k++){
            System.out.println("k --> " + k); // 1 2 ..... 9 10
        }

        // 变形
        for(int k = 1; k <= 10; ){
            System.out.println("k --> " + k); 
            k++;
        }

        // 变形
        for(int k = 1; k <= 10; ){
            k++;
            System.out.println("value --> " + k); // 2 3 4 5 6 7 8 9 10 11
        }

    }
}
复制代码
复制代码
public class ForTest03{
    public static void main(String[] args){

        // for的其它形式
        for(int i = 10; i > 0; i--){
            System.out.println("i = " + i); // 10 9 8 7 6 5 4 3 2 1
        }

        // 变形
        for(int i = 0; i < 10; i += 2){
            System.out.println("value1 = " + i); // 0 2 4 6 8 
        }

        //注意:1对3求余数结果还是1
        /*
        for(int i = 100; i > 0; i %= 3){
            System.out.println("value2 = " + i); // 100 1 1... 1
        }
        */
    }
}
复制代码
复制代码
/*
    使用for循环,实现1~100所有奇数求和
    至少给出两种解决方案。
*/
public class ForTest04{
    public static void main(String[] args){

        //第一种方案:
        // 思路:先找出1~100所有的奇数,然后再考虑求和的事儿。
        // 第一步:先从1取到100,一个数字一个数字取出来。
        // 第二步:既然可以得到每一个数字,那么我们进一步判断这个数字是否为奇数
        // 奇数对2求余数,结果都是1
        int sum = 0; // 初始值给0
        for(int i = 1; i <= 100; i++){
            // int sum = 0; // 不能在这个循环体中声明,这样会导致“计算器归0”
            //for循环中嵌套了if语句。
            if(i % 2 == 1){ // i为奇数的条件
                //System.out.println("i = " + i);
                sum += i; // 累加 (sum = sum + i;)
            }
        }
        // 一定是在for循环全部结束之后,输出的sum就是最终的结果。
        System.out.println("1~100所有奇数求和结果是:" + sum); // 2500

        //第二种方案:这种方案效率高,因为循环次数比较少。
        // 之前的sum归0.重新求和。
        sum = 0;
        for(int i = 1; i < 100; i += 2){
            //这样写可以保证每一次取出的值都是奇数。不需要判断。
            //System.out.println(i);
            sum += i;
        }
        System.out.println(sum);
        
    }
}
复制代码
复制代码
/*
1、所有合法的“控制语句”都可以嵌套使用。
2、for循环嵌套一个for循环执行原理是什么?
    提示一下:大家不要因为for循环中嵌套了一个for循环,就感觉
    这个程序比较特殊,实际上大家可以这样看待:
        for(){
            //在分析外层for循环的时候,把里面的for就当做一段普通的java语句/代码.
            for(){}
        }
*/
public class ForTest05{
    public static void main(String[] args){

        // 单层for循环
        for(int i = 0; i < 10; i++){ 
            System.out.println("i = " + i);
        }

        for(int k = 0; k < 2; k++){ // 循环2次
            System.out.println("k = " + k);
        }

        for(int k = 0; k < 2; k++){ // 循环2次
            //System.out.println("k ==> " + k);
            for(int i = 0; i < 10; i++){ 
                System.out.println("i ---> " + i);
            }
        }
        
        /*
        int i = 0;
        for(int k = 0; k < 2; k++){
            //System.out.println("k's value = " + k);
            for(; i < 10; i++){ 
                System.out.println("k's value = " + k);
                System.out.println("value ---> " + i);
            }
        }
        */
        
        
        for(int k = 0; k < 2; k++){
            for(int i = 0; i < 10; i++){ 
                System.out.println("k's value = " + k); 
                System.out.println("value ---> " + i); 
            }
        }

        /*
        // 第一遍
        for(int i = 0; i < 10; i++){ 
            System.out.println("i ==> " + i);
        }

        // 第二遍
        for(int i = 0; i < 10; i++){ 
            System.out.println("i ==> " + i);
        }
        */

    }
}
复制代码
复制代码
/*
    九九乘法表

    1*1=1
    1*2=2 2*2=4
    1*3=3 2*3=6 3*3=9
    1*4=4 2*4=8 3*4=12 4*4=16
    ....
    ......
    1*9=9 2*9=18.............................9*9=81

    各位,请找一下以上九九乘法表的特点?????
        第一个特点:共9行。
        第二个特点:第1行1个。第2行2个。第n行n个。
    
    最重要的是:不要慌,慢慢的把思路捋出来,再写代码。
*/
public class ForTest06{
    public static void main(String[] args){
        
        // 9行,循环9次。
        for(int i = 1; i <= 9; i++){ // 纵向循环
            //System.out.println(i); // i是行号(1~9)
            // 负责输出一行的。(内部for循环负责将一行上的全部输出。)
            for(int j = 1; j <= i; j++){ // i是行号
                System.out.print(j + "*" + i + "=" + i * j + " ");
            }
            // 换行
            System.out.println();
        }
    }
}
复制代码
复制代码
/*
    while循环:
        1、while循环的语法机制以及执行原理
            语法机制:
                while(布尔表达式){
                    循环体;
                }
            执行原理:
                判断布尔表达式的结果,如果为true就执行循环体,
                循环体结束之后,再次判断布尔表达式的结果,如果
                还是true,继续执行循环体,直到布尔表达式结果
                为false,while循环结束。

        2、while循环有没有可能循环次数为0次?
            可能。
            while循环的循环次数是:0~n次。
*/
public class WhileTest01{
    public static void main(String[] args){
        // 死循环
        /*
        while(true){
            System.out.println("死循环");
        }
        */

        // 本质上while循环和for循环原理是相同的。
        /*
            for(初始化表达式; 布尔表达式; 更新表达式){
                循环体;
            }

            初始化表达式;
            while(布尔表达式){
                循环体;
                更新表达式;
            }

            if switch属于分支语句属于选择语句。
            for while do..while..这些都是循环语句。
            可以正常互相嵌套。
        */
        for(int i = 0; i < 10; i++){
            System.out.println("i --->" + i);
        }
        
        /*
        int i = 0;
        while(i < 10){
            System.out.println("i = " + i);
            i++;
        }
        */

        // for和while完全可以互换,只不过就是语法格式不一样。
        for(int i = 0; i < 10; ){
            i++;
            System.out.println("i --->" + i); // 1 2 3 .. 9 10
        }

        int i = 0;
        while(i < 10){
            i++;
            System.out.println("i = " + i); // 1 2 3 .. 9 10
        }


    }
}
复制代码
复制代码
/*
    do..while循环语句的执行原理以及语法机制:
        语法机制:
            do {
                循环体;
            }while(布尔表达式);

        注意:do..while循环最后的时候别漏掉“分号”

        执行原理:
            先执行循环体当中的代码,执行一次循环体之后,
            判断布尔表达式的结果,如果为true,则继续执行
            循环体,如果为false循环结束。
        
        对于do..while循环来说,循环体至少执行1次。循环体的执行次数是:1~n次。
        对于while循环来说,循环体执行次数是:0~n次。
        
*/
public class DoWhileTest01{
    public static void main(String[] args){
        //错误: 需要';'
        /*
        int i = 0;
        do{
            System.out.println(i);
            i++;
        }while(i < 10)
        */
        
        /*
        int i = 0;
        do{
            System.out.println(i); // 0 1 2 3 ... 8 9
            i++;
        }while(i < 10);
        */

        /*
        int i = 0;
        do{
            System.out.println(i++); // 0 1 2 3 ... 8 9
        }while(i < 10);
        */

        int i = 0;
        do{
            //System.out.println(++i); // 1 2 3 ... 8 9 10

            // 把上面那一行代码拆分为以下的两行代码。
            int temp = ++i;
            System.out.println(temp); // 程序执行到此处的时候i是10

        }while(i < 10);

        System.out.println("-----------------------------");
        int k = 100;
        System.out.println(++k); // 101
        System.out.println(k); // 101

        int m = 10;
        System.out.println(m++); // 10
        System.out.println(m); // 11


        // 至少执行1次循环体。
        do{
            System.out.println("Hello World!");
        }while(false);

    }
}
复制代码

 



2.5、转向语句
break
continue
return(这个目前先不需要学习,后面讲方法的时候会使用。)

 

复制代码
/*
    break;语句:
        1、break;语句比较特殊,特殊在:break语句是一个单词成为一个完整的java语句。
        另外:continue也是这样,他俩都是一个单词成为一条语句。

        2、break 翻译为折断、弄断。

        3、break;语句可以用在哪里呢?
            用在两个地方,其它位置不行
            第一个位置:switch语句当中,用来终止switch语句的执行。
                用在switch语句当中,防止case穿透现象,用来终止switch。

            第二个位置:break;语句用在循环语句当中,用来终止循环的执行。
                用在for当中
                用在while当中
                用在do....while..当中。
        
        4、以下程序主要是以for循环为例学习break转向语句。

        5、break;语句的执行并不会让整个方法结束,break;语句主要是用来终止离它最近
        的那个循环语句。

        6、怎么用break;语句终止指定的循环呢?
            第一步:你需要给循环起一个名字,例如:
                a: for(){
                    b:for(){
                    
                    }
                }
            第二步:终止:break a;
*/
public class BreakTest01{

    public static void main(String[] args){

        // 输出0-9
        /*
        for(int i = 0; i < 10; i++){
            System.out.println("i = " + i);
        }
        */

        for(int i = 0; i < 10; i++){
            if(i == 5){
                // break;语句会让离它最近的循环终止结束掉。
                break; // break;终止的不是if,不是针对if的,而是针对离它最近的循环。
            }
            System.out.println("i = " + i); // 0 1 2 3 4
        }

        // 这里的代码照常执行。break;的执行并不会影响这里。
        System.out.println("Hello World!");

        // 这个for循环两次
        for(int k = 0; k < 2; k++){ // 外层for
            for(int i = 0; i < 10; i++){ // 内层for
                if(i == 5){
                    break; // 这个break;语句只能终止离它最近的for
                }
                System.out.println("i ===> " + i); 
            }
        }

        System.out.println("------------------------------------------");

        // 以下讲解的内容,以后开发很少用。不要紧张。
        // 这种语法很少用,了解一下即可。
        a:for(int k = 0; k < 2; k++){ 
            b:for(int i = 0; i < 10; i++){
                if(i == 5){
                    break a; // 终止指定的循环。
                }
                System.out.println("i ===> " + i); 
            }
        }

        System.out.println("呵呵");

    }
}
复制代码

 

复制代码
/*
    continue;语句:
        1、continue翻译为:继续
        2、continue语句和break语句要对比着学习
        3、continue语句的作用是:
            终止当前"本次"循环,直接进入下一次循环继续执行。
            for(){
                if(){ // 当这个条件成立时,执行continue语句
                    continue; //当这个continue语句执行时,continue下面的代码不执行,直接进入下一次循环执行。
                }
                // 以上的continue一旦执行,以下代码不执行,直接执行更新表达式。
                code1;
                code2;
                code3;
                code4;
            }

        4、continue语句后面可以指定循环吗?
            可以的。
            这里就不再讲了,自己测试以下。
            a:for(;;更新表达式1){
                b:for(;;更新表达式2){
                    if(){
                        continue a;
                    }
                    code1;
                    code2;
                    code3;
                }
            }
*/
public class ContinueTest01{
    public static void main(String[] args){

        /*
            i = 0
            i = 1
            i = 2
            i = 3
            i = 4
        */
        for(int i = 0; i < 10; i++){
            if(i == 5){
                break;
            }
            System.out.println("i = " + i);
        }

        System.out.println("----------------------------");

        /*
            i = 0
            i = 1
            i = 2
            i = 3
            i = 4
            i = 6
            i = 7
            i = 8
            i = 9
        */
        for(int i = 0; i < 10; i++){
            if(i == 5){
                continue;
            }
            System.out.println("i = " + i); // 输出i是4
        }

    }
}
复制代码

 

 

3、选择语句/分支语句if

4、选择语句switch

 

 

 

day09 课堂笔记

1、控制语句

1.1、关于循环语句
for循环
while循环
do..while循环

什么是循环语句,为什么要使用这种语句?
因为在现实世界当中,有很多事情都是需要反复/重复的去做。
对应到程序当中,如果有一块代码需要重复执行,此时为了减少
代码量,我们使用循环语句。

1.2、关于转向语句:
break;
continue;
return;(return语句后期讲到方法的时候再详细学习。目前先不用管。)

 

复制代码
/*
    应该怎么去编程???????

    计算1000以内所有不能被7整除的整数之和
        1、解决一个问题的时候,可以先使用汉语描述思路。(养成好习惯)
        2、复杂的问题可以“一步一步”去实现,没必要一下全部实现。
    
    把上面的题目可以拆分成几步去完成:

        第一步:从1开始循环,循环到1000,先保证每一个数字你都能取到。

        第二步:在以上第一步的循环过程中,一个数字一个数字筛查,判断该数字是否
        是“不能被7整除的整数”。
    
    编程思想/思路,都是一步一步分析,积累出来的。
    编程最主要的是写汉语思路。思路有了,代码就不远了。

    把问题拆开,一个一个去解决一下。

    不断写代码,不断的积累编程“模型”。
*/
public class Homework1{

    public static void main(String[] args){

        // 在外部准备一个变量,用来存储求和的结果
        int sum = 0;

        //循环的时候你能想起来for while do..while
        for(int i = 1; i <= 1000; i++){ //第一步

            // 判断的时候你能想起来使用if
            if(i % 7 != 0){ // 第二步
                // 此时的i是不能被7整除的,这个i应该此时纳入求和/累加。
                //sum += i;
                sum = sum + i;
            }

        }

        // 在for循环结束之后,结果才计算完成,所以在这里输出。
        System.out.println("sum = " + sum); //429429


    }
}
复制代码

 

复制代码
// 计算 1+2-3+4-5+6-7....+100的结果
// 找规律:奇数时减法,偶数时加法。
// 第一种思路:(除1之外)所有的偶数求和,所有的奇数求和,然后偶数求和的结果减去奇数求和的结果。
// 第二种思路:循环过程中取出每个值,判断该数是偶数还是奇数,偶数就加,奇数就减。

//写代码养成好习惯是:写一步测试一步。
public class Homework2{
    public static void main(String[] args){
        // 第一步:先别着急着完成,先能从1取到100
        int sum = 1; //sum的初始值不是0,而是1.
        for(int i = 2; i <= 100; i++){ // i从2开始。
            if(i % 2 == 0){ //偶数
                sum += i;
            }else{ // 奇数
                sum -= i; 
            }
        }
        System.out.println("结果=" + sum); // 52
    }
}
复制代码
复制代码
//从控制台输入一个正整数,计算该数的阶乘。例如输入5,阶乘为 5*4*3*2*1
public class Homework3{
    public static void main(String[] args){
        //第一步:怎么从键盘上接收一个正整数。
        java.util.Scanner s = new java.util.Scanner(System.in);
        // 等待用户输入一个正整数。
        System.out.print("请输入一个正整数:");
        int num = s.nextInt();
        // 计算该数的阶乘
        // 5的阶乘:5*4*3*2*1
        // 8的阶乘:8*7*6*5*4*3*2*1
        // 第二步:先不用管乘法的事儿,先实现从8取到1.(递减的方式取)
        //int jieGuo = 0; //初始值不能是0,是0的时候,乘积最后是0.
        int jieGuo = 1; //结果的初始值给1.
        for(int i = num; i > 1; i--){
            jieGuo *= i; // jieGuo = jieGuo * i;
        }
        System.out.println("计算结果 = " + jieGuo);
    }
}
复制代码
复制代码
/*
从控制台接收一个正整数,判断该数字是否为质数
质数(质数是指在大于1的自然数中,除了1和它本身以外不再有其他因数的自然数)

因数是什么?
    3 * 5 = 15
    3和5都是15的因数。

2 3 4 5 6 7中:2 3 5 7都是质数。

重点题目:
    主要练习,在外部打布尔标记。

*/
public class Homework4{
    public static void main(String[] args){
        // 从控制台接收一个正整数。
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入一个正整数:");
        int num = s.nextInt(); // 假设输入的是8

        // 判断该数字是否为质数
        // 怎么判断num是不是质数
        // 怎么判断8是不是质数?
        // 思路:8除以2看看能不能整除、8除以3看看能不能整除、8除以4看看能不能整除
        // 一直除下去,直到发现有能够整除的,表示该数一定不是质数。
        /*
            假设输入的是7:
                7 / 1 不用判断
                7 / 2    需要判断
                7 / 3    需要判断
                7 / 4    需要判断(假设这个判断,发现可以整除,就没必要往下判断了。)
                7 / 5    需要判断
                7 / 6    需要判断
                7 / 7 不用判断
        */

        //可以考虑在外边准备一个布尔类型的标记。
        boolean zhiShu = true; // true表示是质数。

        for(int i = 2; i < num; i++){ // 假设输入的是100
            //System.out.println(i);
            if(num % i == 0){
                // 循环没必要执行了,为了效率,这里要终止循环
                //System.out.println("该数字"+num+"不是质数!");
                zhiShu = false;
                break;
            }
        }

        System.out.println(num + (zhiShu ? "是" : "不是") + "质数");
    }
}
复制代码
复制代码
/*
从键盘接收一个正整数,该正整数作为行数,输出以下图形
    *
   ***
  *****
 *******
*********
例如:输入5,则打印如上图5行。

空格的规律:
    第1行4个空格(5-1)
    第2行3个空格(5-2)
    第3行2个空格(5-3)
    第4行1个空格(5-4)
    第5行0个空格(5-5)

星号的规律:
    第1行1个
    第2行3个
    第3行5个
    第4行7个
    .....

    行号 * 2 - 1
*/
public class Homework5{
    public static void main(String[] args){
        // 开发需要思路,实现这个功能需要一步一步来。
        // 这个步骤是什么?
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入一个正整数作为行数:");
        int rows = s.nextInt();
        
        // 6行循环6次
        // n行循环n次
        for(int i = 1; i <= rows; i++){ // 外层循环控制的是总行数。
            
            // 我在这里需要将一行全部输出
            // 这里需要再使用循环,输出空格以及“*”
            // 输出空格的循环
            for(int j = 0; j < rows - i; j++){
                System.out.print(" ");
            }
            // 输出星号*的循环
            for(int k = 0; k < i * 2 - 1; k++){
                System.out.print("*");
            }

            // 以上两个for循环都结束之后,表示一行就结束了
            // 在这里换行
            System.out.println();
        }

    }
}
复制代码
复制代码
/*
小芳的妈妈每天给她2.5元钱,她都会存起来,但是,每当这一天是存钱的第5天
或者5的倍数的话,她都会花去6元钱,请问,经过多少天,小芳才可以存到100元钱。

这个题目最主要练习是:
    while循环 + 计数。
*/
public class Homework6{
    public static void main(String[] args){

        // 小芳每一天肯定会有2.5元的收入。
        // 小芳即使有一天花了6元,但是2.5元的收入还是有的。
        // 经过分析:总钱数肯定需要是double类型。int类型不行。

        int day = 0; // 天数的默认初始值是0
        double money = 0.0; // 钱的默认初始值是0

        /*
        while(true){
            day++; // 天数加1
            money += 2.5; // 钱加2.5元
            // 如果天数是5的倍数,那么花去6元
            if(day % 5 == 0){
                money -= 6.0;
            }
            // 什么时候循环结束呢?
            // 当money >= 100.0的时候,循环结束。
            if(money >= 100){
                break;
            }
        }
        */

        // 改造之后的。
        while(money < 100){
            day++; // 天数加1
            money += 2.5; // 钱加2.5元
            // 如果天数是5的倍数,那么花去6元
            if(day % 5 == 0){
                money -= 6.0;
            }
        }

        //小芳通过74天存到了101.0元钱
        System.out.println("小芳通过" + day + "天存到了" + money + "元钱");

    }
}
复制代码
复制代码
/*
一个数如果恰好等于它的因子之和,这个数就是完数,例如 6 = 1 + 2 + 3,编程
找出1000内所有的完数。

什么是完数?
    一个数如果恰好等于它的因子之和,这个数就是完数。

那么因子怎么找?
    10的因子?
        10 % 1 == 0
        10 % 2 == 0
        10 % 5 == 0
    不算10本身。
    10的因子:
        1 + 2 + 5 = 8

运行结果:
    6
    28
    496
*/
public class Homework7{
    public static void main(String[] args){
        // 1不属于完数。从2开始判断
        // 第一步:先从1到1000,每个数字都取出来
        for(int i = 2; i <= 1000; i++){
            // 第二步:在这里可以拿到i,那么此时应该判断i是否是一个完数。
            // 这个数字有了,找这个数字的因子。
            // 假设现在这个数字就是6,i等于6
            int sum = 0;
            for(int j = 1; j <= i / 2; j++){
                //j取到的值是:1 2 3 4 5
                //但实际上j取到哪儿就行了:1 2 3,取这几个数就行了。
                //取到一半就行。
                if(i % j == 0){
                    //此时j就是因子。
                    // 记得将因子j追加,累计。
                    sum += j;
                }
            }
            // 以上for结束表示:所有因子求和完毕了。
            if(i == sum){
                //i是一个完数
                System.out.println(i);
            }
        }
    }
}
复制代码
复制代码
/*
根据指定月份,打印该月份所属的季节。
    3,4,5 春季 
    6,7,8 夏季 
    9,10,11 秋季 
    12, 1, 2 冬季

    if和switch各写一版
*/
class Homework1{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入合法的数字【该数字可以是:1 2 3 4 5 6 7 8 9 10 11 12】:");
        int i = s.nextInt();

        // if版本
        /*
        String str = "输入的数字不合法";
        if(i == 3 || i == 4 || i == 5){
            str = "春季";
        }else if(i == 6 || i == 7 || i == 8){
            str = "夏季";
        }else if(i == 9 || i == 10 || i == 11){
            str = "秋季";
        }else if(i == 12 || i == 1 || i == 2){
            str = "冬季";
        }
        System.out.println(str);
        */

        // switch版本
        String str = "输入的数字不合法";
        switch(i){
        case 3:case 4:case 5:
            str = "春季";
            break;
        case 6:case 7:case 8:
            str = "夏季";
            break;
        case 9:case 10:case 11:
            str = "秋季";
            break;
        case 12:case 1:case 2:
            str = "冬季";
        }
        System.out.println(str);

    }
}

//从键盘接收一个数字,判断该数字的正负
class Homework2{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入一个数字,我可以判断正负哦:");
        // 接收一个数字
        //int value = s.nextInt();
        double value = s.nextDouble();
        // 判断该数字正负
        /*
        if(value < 0){
            System.out.println("负数");
        }else{
            System.out.println("正数");
        }
        */
        System.out.println(value < 0 ? "负数" : "正数");
    }
}

//从键盘接收一个数字,判断该数字的奇偶。
class Homework3{
    public static void main(String[] args){
        
        //创建一次。
        java.util.Scanner s = new java.util.Scanner(System.in);

        while(true){
            System.out.print("请输入一个数字,可以判断奇数偶数哦(输入0表示退出系统):");
            int value = s.nextInt();
            if(value == 0){
                // 退出系统,结束程序
                return; //后面讲。
            }
            System.out.println(value % 2 == 0 ? "偶数" : "奇数");
        }
    }
}

/*
整数大小比较:输入两个整数,比较大小,
    若x>y 输出 >
    若x=y 输出 =
    若x<y 输出 <
*/
class Homework4{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入第1个数字:");
        int x = s.nextInt();
        System.out.print("请输入第2个数字:");
        int y = s.nextInt();
        if(x > y){
            System.out.println(x + ">" + y);
        }else if(x == y){
            System.out.println(x + "=" + y);
        }else{
            System.out.println(x + "<" + y);
        }
        // 同学们尝试一下使用多个三目运算符如何表述以上程序。
    }
}


/*
编写程序,由键盘输入三个整数分别存入变量num1,num2,num3中,对它们进行排序,
使用if-else结构,并按从小到大的顺序输出
*/
class Homework5{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入第1个数字:");
        int x = s.nextInt();
        System.out.print("请输入第2个数字:");
        int y = s.nextInt();
        System.out.print("请输入第3个数字:");
        int z = s.nextInt();

        // 先判断三个值是否都相等
        if(x == y && y == z){
            System.out.println(x);
            System.out.println(y);
            System.out.println(z);
            return; //终止掉程序,后面讲
        }

        // 代码能够走到这里说明x y z不是都相等。
        // x和y相等,但是和z不等 
        if(x == y){
            if(x > z){
                System.out.println(z);
                System.out.println(x);
                System.out.println(y);
            }else{
                System.out.println(x);
                System.out.println(y);
                System.out.println(z);
            }
        }
        // x和z相等,但是和y不等
        if(x == z){ 
            if(x > y){
                System.out.println(y);
                System.out.println(x);
                System.out.println(z);
            }else{
                System.out.println(x);
                System.out.println(z);
                System.out.println(y);
            }
        }
        // y和z相等,但是和x不等
        if(y == z){ // x y z
            if(y > x){
                System.out.println(x);    
                System.out.println(y);    
                System.out.println(z);    
            }else{
                System.out.println(y);    
                System.out.println(z);    
                System.out.println(x);
            }
        }

        // 程序执行到这里说明 x y z 都不相等
        /*
        if(x > y){
            if(y > z){
                System.out.println(z);
                System.out.println(y);
                System.out.println(x);
            }else{ 
                if(x < z){
                    System.out.println(y);
                    System.out.println(x);
                    System.out.println(z);
                }else{
                    System.out.println(y);
                    System.out.println(z);
                    System.out.println(x);
                }
            }
        }else{
            // x < y
            // 50 < 100
        }
        */

        // 不算相等的,一共有6种情况。
        if(x > y && x > z){ // 假设x是最大的
            if(y > z){
                System.out.println(z);
                System.out.println(y);
            }else{
                System.out.println(y);
                System.out.println(z);
            }
            System.out.println(x);
        }else if(y > x && y > z){ // 假设y是最大的
            if(x > z){
                System.out.println(z);
                System.out.println(x);
            }else{
                System.out.println(x);
                System.out.println(z);
            }
            System.out.println(y);
        }else{ //假设z是最大的
            if(x > y){
                System.out.println(y);
                System.out.println(x);
            }else{
                System.out.println(x);
                System.out.println(y);
            }
            System.out.println(z);
        }
        

    }
}

/*
打车起步价8元(3KM以内)
超过3KM,超出的每公里1.2元
超过5KM,超出的每公里1.5元
请在键盘上接收公里数,得出总价。
*/
class Homework6{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入行驶的公里数:");
        int dis = s.nextInt(); 
        if(dis <= 3){
            System.out.println("总价是:" + 8 + "元");
        }else if(dis <= 5){
            System.out.println("总价是:" + ((dis - 3) * 1.2 + 8) + "元");
        }else{
            // 公里超出5KM
            System.out.println("总价是:" + ((8 + 2 * 1.2) + (dis - 5) * 1.5) + "元");
        }
    }
}
复制代码

 

 

 

 

day10课堂笔记

1、今天三件事
第一:回顾之前所有的内容
第二:讲解昨天的所有作业题
第三:布置大量的练习题,坚决这个周末大家把之前所学习的所有内容全部掌握。

2、回顾
2.1、windows操作系统中,文件扩展名的展示。
2.2、安装EditPlus并且进行相关配置。
2.3、windows的dos命令
cls 清屏
exit 退出
ipconfig 查看IP地址
ping 查看两台计算机之间是否可以正常通信
d: 回车 切换盘符
cd 命令切换目录:相对路径和绝对路径
C:\Windows>cd System32 相对路径(相对于当前位置而言)
C:\>cd c:\windows\system32 绝对路径(路径以盘符开始)
cd .. 回到上级
cd \ 回到根
mkdir 创建目录
del 删除文件
dir 查看当前目录下有哪些子目录或者子文件

注意:
在DOS命令窗口中,可以使用tab键自动补全。
在DOS命令窗口中,使用上下箭头可以翻出历史命令。
2.4、快捷键:
补充两个windows系统的组合键:
win + r 打开运行窗口
win + d 显示桌面
win + l 锁屏(离开电脑的时候要锁屏)
alt + tab 切换应用
2.5、计算机语言的发展史
第一代
第二代
第三代
2.6、Java语言的发展史
JDK:java开发工具包
JavaSE JavaEE JavaME
SUN公司开发的,带头人:james gosling java之父
2.7、java语言的特点:
简单性
多线程
面向对象
可移植,跨平台:因为JVM的存在。(Java虚拟机屏蔽了操作系统之间的差异)
windows上安装的JDK和Linux上安装的JDK的版本不同。
JDK版本不同,最终JVM的版本也是不同的,每一个操作系统都有自己的JVM。
健壮性:自动GC垃圾回收机制。
2.8、java的加载与执行(java从开发到最终运行,经历了哪些过程)
要求:自己能够从头描述到最后。(不参考任何资料的前提下)
从编写到最终的运行,把过程描述出来。
第一步:
第二步:
.....
2.9、术语
JDK JRE JVM
JDK java开发工具包
JRE java运行时环境
JVM java虚拟机

JavaSE JavaEE JavaME

2.10、开始开发第一个java程序HelloWorld
第一:要会下载对应版本的JDK(http://www.oracle.com)
第二:要会安装JDK(双击,下一步)
第三:配置环境变量path
path=C:\Program Files\Java\jdk-13.0.2\bin
这样javac和java命令就可以使用了。
第四:编写HelloWorld.java程序。
第五:javac进行编译:
javac命令在使用的时候
javac + java源文件的路径(注意:路径包括绝对和相对。)
第六:java命令进行运行
java 类名 (一定要注意:这里不是路径。是类名)
这里涉及到另一个环境变量叫做:classpath
classpath没有配置的情况下:从当前路径下找xxx.class文件
classpath设置了具体路径之后,不再从当前路径下找了。

重点掌握path和classpath两个环境变量。
2.11、java语言中的注释:

// 单行注释

/*
多行注释
*/
/**
* javadoc注释
*/
2.12、public class 和class的区别
一个java文件中可以定义多个class
一个class编译之后会生成1个class字节码文件,2个class编译之后会生成2个class文件
任何一个class中都可以编写main方法,每一个main方法都是一个入口
public的类可以没有
public的类如果有的话,只能有1个,并且public的类名要求和文件名一致。
class A{
main(){}
}
java A

class B{
main(){}
}
java B
....
2.13、标识符
标识符可以标识什么?
类名、接口名
变量名、方法名
常量名
标识符的命名规则?
标识符只能由数字 字母(可以有中文) 下划线 美元符号组成,不能有其它符号。
标识符不能以数字开始
标识符严格区分大小写
关键字不能做标识符
理论上没有长度限制
标识符的命名规范?
见名知意
驼峰命名方式,一高一低
类名、接口名:首字母大写,后面每个单词首字母大写。
变量名、方法名:首字母小写,后面每个单词首字母大写。
常量名:全部大写,每个单词之间使用下划线衔接。

标识符在editplus中是黑色字体。

2.14、关键字
关键字都是全部小写的,在editplus中以蓝色显示。
不需要特意记忆,一边学习一边记忆。
public
class
static
void
byte
short
int
long
float
double
boolean
char
true
false
if
else
switch
for
while
break
continue
........

2.15、变量

什么是变量,怎么理解的?
一个存储数据的盒子,
一个存储数据的单元。
int i = 100;
System.out.println(i);

什么是字面量,怎么理解的?
1 2 3 4 -100 100 整数型字面量
3.14 浮点型的字面量。
true false 布尔型字面量
'a' '中' 字符型字面量
"abc" "a" 字符串型的字面量
字面量其实本质上就是“数据”。

变量怎么声明,怎么赋值?
声明:
数据类型 变量名;
int i;
赋值:用=赋值
变量名 = 字面量;
i = 100;
重新赋值:i = 200;

变量在同一个域当中不能重名。
{
int i = 2;
double i = 2.0;
//报错了,重名了。
}
变量的分类?
在方法体当中声明的就是局部变量。
在方法体外面声明的就是成员变量。

变量的作用域?
出了大括号就不认识了。
每一个变量都有自己的有效范围。出了范围就不认识了,就不能用了。

2.16、数据类型
1. 什么是数据类型,有啥用?
数据类型决定了变量分配空间的大小,类型不同,空间大小不同。
(在内存中分配空间)
计算机的主要部件:CPU 内存 硬盘 主板。
2、数据类型分类?
基本数据类型:
byte short int long float double boolean char
引用数据类型:
String..........
3、要求要理解二进制
4、要求理解二进制和十进制之间的互相转换。
5、8种基本数据类型,每个占用空间大小。
类型 字节
------------------
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1
char 2
6、记忆byte short int char的取值范围:
byte -128 ~ 127
short -32768 ~ 32767
int -2147483648 ~ 2147483647
char 0~65535
7、理解字符编码?
什么时候会有乱码?编码和解码采用的不是同一套字符编码方式。
怎么理解字符编码?字符编码是人为制定的,一个字典表,字典中描述了转换关系。
常见的字符编码?
ASCII:
'a' 97
'A' 65
'0' 48
...
ISO-8859-1(latin-1)
GBK
GB2312
GB18030
Big5
unicode : java中采用的统一了全球所有的文字。
8、数据类型详细介绍
char
可以存储1个汉字
用单引号括起来
转义字符:
\t
\n
\'
\"
\\
\u
....
char c = 97;
System.out.println(c); //输出'a'

byte short int long
int最常用
任何一个数字,例如:1232 3 5 9,默认都是当做int处理,想当做long,必须加L或者l
123L这就是long类型
自动类型转换:小-->大
强制类型转换:大-->小,需要加强制类型转换符。另外运行可能损失精度。

当一个整数没有超出byte short char的取值范围,
可以直接赋值给byte short char类型的变量。

在java中整数型字面量表示的时候有四种方式:
10 十进制
010 八进制
0x10 十六进制
0b10 二进制

float double
浮点型的数字默认被当做double来处理,
想以float形式存在,数字后面添加F/f
float f = 1.0; //错误的
float f = 1.0f;
float f = (float)1.0;

要知道浮点型数据在java语言中存储的都是近似值。
还有一点:float和double的空间永远比整数型空间大,比long大。

boolean
boolean类型只有两个值:true false,没有其他值。
布尔类型使用在逻辑运算,条件判断当中。

9、基本数据类型转换的6条规则:
第一条:只有boolean不能转换,其它都行。

第二条:自动类型转换
byte < short(char) < int < long < float < double
char可以取到更大的正整数。

第三条:强制类型转换需要加强制类型转换符。可能损失精度。

第四条:当一个整数没有超出byte short char的取值范围时,可以直接赋值
给byte short char类型的变量。

第五条:byte short char混合运算的时候,各自先转换成int再做运算。

第六条:多种数据类型混合运算的时候,先转换成容量最大的那一种再做运算。

2.17、运算符
算术运算符
+ - * / % ++ --
重点:++
++无论出现在变量前还是后,只要++运算结束,一定会自加1.
int i = 10;
i++;
System.out.println(i); // 11

int k = 10;
++k;
System.out.println(k); // 11

++出现在变量前:
int i = 10;
int k = ++i;
System.out.println(k); // 11
System.out.println(i); // 11

++出现在变量后:
int i = 10;
int k = i++;
System.out.println(k); // 10
System.out.println(i); // 11

int i = 10;
System.out.println(i++); // 10
解开以上题目的窍门是什么?拆代码
int temp = i++;
System.out.println(temp); // 10
System.out.println(i); // 11

int i = 10;
System.out.println(++i);
会拆代码:
int temp = ++i;
System.out.println(temp); // 11
System.out.println(i); // 11

关系运算符
>
>=
<
<=
==
!=
结果都是布尔类型。true/false

逻辑运算符
&
|
!
&&
||

逻辑运算符要求两边都是布尔类型,并且最终结果还是布尔类型。
左边是布尔类型 & 右边还是布尔类型 -->最终结果还是布尔类型。
& 两边都是true,结果才是true
| 一边是true,结果就是true
! 取反

&&实际上和&运算结果完全相同,区别在于:&&有短路现象。
左边的为false的时候:&& 短路了。

左边为true的时候:|| 短路了。

赋值运算符
=
+=
-=
*=
/=
%=
重要规则:
扩展赋值运算符在使用的时候要注意,不管怎么运算,最终的
运算结果类型不会变。

byte x = 100; // byte最大值127

x += 1000; // 编译可以通过,x变量还是byte类型,只不过损失精度了。

x += 1000; 等同于: x = (byte)(x + 1000);

int i = 10;
i += 10; // 等同于:i = i + 10; 累加。

条件运算符
?:
三目
布尔表达式 ? 表达式1:表达式2

布尔表达式为true,选择表达式1作为结果。
反之选择表达式2作为结果。

字符串连接运算符
+
+ 两边都是数字,进行求和。
+ 有一边是字符串,进行字符串的拼接。
+ 有多个的话,遵循自左向右依次执行:1 + 2 + 3
如果想让其中某个加号先执行,可以添加小括号:1 + (2 + 3)
注意:字符串拼接完之后的结果还是一个字符串。

技巧:怎么把一个变量塞到一个字符串当中。
String name = "jackson";
System.out.println("登录成功,欢迎"+name+"回来");

2.18、控制语句

选择语句
if
switch
循环语句
for
while
do..while
转向语句
break;
continue;
return;

1、选择语句/分支语句 if
四种写法。
语法机制:
if(布尔表达式){
}

if(布尔表达式){
}else{
}

if(布尔表达式){
}else if(布尔表达式){
}else if(布尔表达式){
}else if(布尔表达式){
}else if(布尔表达式){
}

if(布尔表达式){
}else if(布尔表达式){
}else if(布尔表达式){
}else if(布尔表达式){
}else if(布尔表达式){
}else{
}

if语句嵌套:
if(布尔表达式){ //前提条件
if(布尔表达式){
if(布尔表达式){

}else{

}
}
}else{

}

执行原理:
对于一个if语句来说,只要有1个分支执行,整个if语句结束。
当布尔表达式的结果为true时,分支才会执行。
分支当中只有一条java语句,大括号可以省略。
带有else的可以保证肯定会有一个分支执行。

2、选择语句/分支语句 switch

完整语法结构:
switch(值){ //值允许是String、int,(byte,short,char可以自动转换int)
case 值1: case 值x:
java语句;
break;
case 值2:
java语句;
break;
case 值3:
java语句;
break;
default:
java语句;
}

3、for循环

for循环语法机制:
for(初始化表达式;条件表达式;更新表达式){
循环体;
}

for(int i = 0; i < 10; i++){
System.out.println(i);
}

for循环执行原理:
1、先执行初始化表达式,并且只执行1次。
2、然后判断条件表达式
3、如果为true,则执行循环体。
4、循环体结束之后,执行更新表达式。
5、继续判断条件,如果条件还是true,继续循环。
6、直到条件为false,循环结束。

4、while循环
while(布尔表达式){
循环体;
}
执行次数:0~N次。

5、do..while循环
do{
循环体;
}while(布尔表达式);

执行次数:1~N次。

6、break;
默认情况下,终止离它最近的循环。
当然,也可以通过标识符的方式,终止指定的循环。

for(int i = 0; i < 10; i++){
if(i == 5){
break;
}
code1;
code2;
code3;
code4;
....
}

7、continue;
终止当前“本次”循环,直接跳入下一次循环继续执行。
for(int i = 0; i < 10; i++){
if(i == 5){
continue;
}
code1;
code2;
code3;
code4;
....
}

 

 
posted @   小carlos  阅读(37)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示