Java---入门基础篇(上)

一、初识Java

1.什么是Java?

Java是一种优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义。

不仅如此，Java还是一个有一系列计算机软件和规范形成的技术体系，这个技术体系提供了完整的用于软件开发和跨平台部署的支持环境，并广泛应用于嵌入式系统、移动终端、企业服务器、大型机等各种场合。

1.1.Java工作领域

Java语言目前在IT领域的应用是非常广泛的，掌握Java语言可以从事不少IT行业的相关开发岗位，具体包括：

• 企业级系统
• Web开发领域
• android平台应用
• 大数据平台开发

1.2.Java与c异同点

类型系统与内存管理

Java 是一种强类型语言，具有自动垃圾回收机制来处理不再使用的对象，这减轻了程序员手动释放内存的工作负担

相比之下，C是一种过程式编程语言，在内存管理和指针操作方面给予开发者更大的控制权，但也因此增加了程序错误的风险

面向对象支持

Java 完全基于面向对象的设计理念构建而成；所有的代码几乎都需要定义在类里面执行。

而C则不具备内置的对象导向特性，尽管可以通过结构体(structures)模拟一些简单的封装形式，但这远不及Java所提供的全面OOP框架那样强大和灵活。

平台独立性

编译后的Java字节码可以在任何安装有JVM(Java虚拟机)的操作系统上运行，实现了真正的跨平台能力。“编写一次，到处运行”的口号正是体现了这一点。然而,C源文件通常会被编译成特定硬件架构下的原生二进制指令集，这意味着为了使同一份应用程序能在不同类型的计算机之间移植，则往往需要重新编译并调整底层实现细节以适应目标环境的要求。

错误处理方式

当遇到异常情况时，Java采用抛出异常的方式通知调用者发生了什么问题，并允许通过try-catch-finally语句块来进行优雅降级或恢复流程逻辑。而在标准库层面之外，C并没有提供类似的机制，大多数情况下依赖于返回状态码告知函数调用方是否成功完成预期动作。

1.3Java软件安装 (IDEA)

【附安装包】IDEA下载、安装、配置与使用（保姆级教程）_idea下载安装教程-CSDN博客

1.4 Java 技术体系

2.第一个Java程序

public class Test {
    public static void main(String[] args) {
     System.out.println("hello world");
    }
}

2.1注意事项:

1.在c 语言中,main函数是程序称为"main函数",而在Java中称为"main方法"

2.在IDEA 中,由于

public static void main(String[] args) {}很长,我们只需要输入main,然后点击Tab 即可生成

同理

System.out.println("hello world");我们只需要输入sout,然后点击Tab 即可生成

3.Java中的打印函数较c 不同,每当我们打印完一句话时,会自动换行

(ln相当于line,打印内容自动添加换行)

4.ctrl+F5快捷运行

也可点击前面的绿色三角符号

5.确保你的文件是.java后缀

6.确保文件名与类名相一致,上图中Test为文件名,注意首字母要大写

此为类名

否则会报错,出现红色波浪线

2.2Java程序编译运行过程 

由编译器将.Java文件（Java的源代码文件）转换为.class字节码文件

JVM再运行.class字节码文件，执行里面的逻辑

3.注释

3.1什么是注释?

解释说明程序含义,方便自己与别人观看,因为在工作中,修改代码非常常见,我们很容易忘记代码含义,所以可以对一些关键代码或者不易理解的代码进行注释

3.2注释的快捷方式

ctrl+/能够对选中的部分进行注释,再次点击取消注释

3.3注释有哪些?

• 单行注释://
• 多行注释:/* ......*/
• 文档注释:/**......*/

注意事项:

1. 多行注释不能嵌套使用

2. 不论是单行还是多行注释，都不参与编译，即编译之后生成的.class文件中不包含注释信息

4.标识符 

4.1什么是标识符?

在编程语言中，标识符是用来给变量、常量、函数、类、接口等元素命名的字符序列。它们是编程时使用的“名字”，建立起名称与使用之间的关系。标识符的命名不仅有助于代码的理解和维护，而且是编程语言语法的一部分。

4.2标识符起名规则

硬性规则:

标识符中可以包含：字母、数字以及 下划线和 $ 符号等等。

注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写。

软性建议 :

类名：每个单词的首字母大写(大驼峰)eg:StudentName

方法名：首字母小写，后面每个单词的首字母大写(小驼峰)eg:studentName

变量名：与方法名规则相同

4.3关键字 

通过观察上述程序可以发现，public、class以及static等颜色会发生变化，将这些具有特殊含义的标识符称为关键字。即：关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字。
 

二 、数据类型和变量

1.字面常量

常量即程序运行期间，固定不变的量称为常量

public class Test{
   public static void main(String[] args){
      System.Out.println("hello world!");
      System.Out.println(100);
      System.Out.println(3.14);
      System.Out.println('A');
      System.Out.println(true);
      System.Out.println(false);
  }
}

其中：100、3.14、‘A’、true/false都是常量，将其称为字面常量

1.1字面常量的分类

1. 字符串常量：由双引号" "括起来的，比如“12345”、“hello”、“你好”。

2. 整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000

3. 浮点数常量：程序中直接写的小数，比如：3.14、0.49

4. 字符常量：由 单引号' ' 括起来的当个字符，比如：‘A’、‘1’

5. 布尔常量：true和false(只有这两种)

6. 空常量：null

注意：字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。

2数据类型

2.1数据类型的种类

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。

数据类型	关键字	内存占用	范围
字节型	byte	1字节	-128~127
短整型	short	2字节	-32768~32767
整型	int	4字节	-~-1
长整型	long	8字节	-~-1
单精度浮点数	float	4字节	有范围，一般不关注
双精度浮点数	double	8字节	有范围，一般不关注
字符型	char	2字节	0~65535
布尔型	boolean	没有明确规定	true与false

2.2.什么是字节？

字节是存储空间的单位，在计算机中使用二进制表示和存储数据，一个二进制位称为1个比特

8个二进制位构成一个字节(Byte)

1024 Byte=>1KB

1024KB=>1MB

1024MB=>1GB

1024GB=>1TB        

8个二进制位中，第一位表示正负号，由于只用0，1存储，所以=128，即1字节的范围为-128~127

注意：

1.与c 不同，Java在32位系统与64位系统中，int都占4个字节，long都占8个字节 

2.与c 不同，Java的字符型char占2个字节，表示范围更大，可以包含中文(常用字)

3.整型和浮点型都带有符号

4.float的精度和范围都非常有限，所以我们一般用double

  short的范围太小，所以一般用int

5.使用long类型时，数字后面加上L/l

6.数字太长时，可以用_进行分割

7.与C相同的是,也是ascii编码的方式来表示字符，包括汉字

ASCII 表 | 菜鸟教程

要表示汉字的,此处Java中使用了Unicode这样的方式来进行编码

查看字符编码（UTF-8）

此网站可以将汉字转化为Unicode编码

到这里，大家可能对Unicode和 ASCII 存在疑惑，可以参考一下下面这篇文章

彻底搞清楚ASCII，Unicode和UTF-8之间的关系_ascii utf8 关系-CSDN博客

3.变量

3.1概念与格式

        int t = 20;
        System.out.println(t);
        t =100;
        System.out.println(t);

数据类型 变量名 = 初始值 ;

        char c ='中';
        long d = 100_0000_0000l;//长整型后面得加L
        int a = 4;
        double b = 3.14;

可以在一行定义多个变量（不建议）

int a = 4,q = 6,o = 9;

3.2整型变量

3.2.1整型变量

1.定义整型变量

        int a = 2;//在定义时给出初始值（建议这种方法）
        System.out.println(a);
        int b ;//可以先定义变量但是在使用前必须 设置初值 
        b = 3;
        System.out.println(b);
        int c;//如果在使用前没有复制出值则编译期间会报错 
        System.out.println(c);
        c=4;

2.int型变量的范围（超过范围会导致溢出）

 System.out.println(Integer.MIN_VALUE);//int 的范围
 System.out.println(Integer.MAX_VALUE);
//输出范围为-2147483648~2147483647

注意：integer是int的包装类，后续会介绍 

3.2.2长整型变量

 1.定义长整型变量

        int c = 10;
        long d = 100_0000_0000L; // long定义的长整型变量,如果超出了int的范围，后面必须加上L（大小写均可，建议大写，否则不容易区分）
        long a = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l

 2.long型变量的范围（超过范围会导致溢出）

        System.out.println(Long.MIN_VALUE);//long 的范围
        System.out.println(Long.MAX_VALUE);
        //输出范围为-9223372036854775808~9223372036854775807

注意：Long是long的包装类，后续会介绍 

3.2.3短整形变量

1.定义短整形变量

short a = 10;
System.out.println(a);

2.short型变量的范围（范围很小，使用时一定要注意是否溢出）

System.out.println(Short.MIN_VALUE);
System.out.println(Short.MAX_VALUE);

 3.2.4字节型变量

byte b = 10;
System.out.println(b);
// byte型变量所能表示的范围：
System.out.println(Byte.MIN_VALUE);
System.out.println(Byte.MAX_VALUE);

 3.3浮点型变量

3.3.1双精度浮点型

1.定义双精度浮点型变量

 double c = 3.14;
 System.out.println(c);

int a = 1;
int b = 2;
System.out.println(a / b);

3.特殊注意

double c = 1.1;
System.out.println(c*c);

• 结果为1.2100000000000002
• 因为double，float这样的类型，无法精确的表示一个小数，是会存在误差的，不只是Java，像C，C++，Python都会有类似问题
• double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势 必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值
• double的包装类型为Double

3.3.2单精度浮点数

float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);

• 注意：与long类似
• 对于1.5字面值常量，默认是double类型，要想定义float类型，需要F/f作为后缀 
• float 类型同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数 都优先考虑 double, 不太推荐使用 float.
• float的包装类型为Float。

3.4字符型变量

• 在Java中字符类型是通过2个字节来表示的（使用Unicode编码对内容进行编排）
• 更严谨的说法：char是使用Unicode的子集，以前Unicode早期版本使用两个字节足够了，当时Java就规定char是两个字节，但是随着时代发展，Unicode包含内容更多，导致2 个字节表示不下了，改也来不及。
• 但是，虽然当前Java的char不能表示全部Unicode至少可以把常用的都表示出来

char c1 = 'A'; // 大写字母
char c2 = '1'; // 数字字符
System.out.println(c1);
System.out.println(c2);

char的包装类型为Character

3.5布尔类型

只有true和false两种（小写）

boolean b = true;
System.out.println(b);
b = false;
System.out.println(b);

注意事项：

• 在Java中boolean类型是单独的类型，true和false就是这个单独类型的字面值，与int类型无关和0或非0这样的设定无关，而不像在c 语言中，表达式非0表示true，表达式为0表示false
• Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节
• boolean 的包装类型为 Boolean

3.6类型转换 

不同类型之间的变量相互赋值就会涉及到类型转换

从上图中我们可以发现int类型可以赋值给long类型，但是long类型却不可以赋值给int类型

3.6.1自动类型转换(隐式)

不需要写任何额外代码，自动转换

特点：数据范围小的转换为数据范围大的会自动执行，在将int赋值给long时，会自动转换为long类型

float f = 3.14F;
double d = 5.12;
d = f; // 编译器会将f转换为double，然后进行赋值
f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

3.6.1强制类型转换(显式)

手动写要怎么转换类型，也叫做强制类型转换

a=(int)b;

注意：如果b的值太大例如100_0000_0000，超出int的范围，进行强制转换的时候会把超出的部分舍弃掉

虽然这样也会有风险，但是编译器会认为程序员知道这个风险，仍想要强制转换

需要注意：强制转换不一定能成功，不相干的类型不能相互转换，eg：将字符串转成整数 

int a = 10;
long b = 100L;
b = a; // int-->long，数据范围由小到大，隐式转换
a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
float f = 3.14F;
double d = 5.12;
d = f; // float-->double，数据范围由小到大，隐式转换
f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
a = d; // 报错，类型不兼容
a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257; // 257默认为int，超过byte范围，如果一定要转换，需要显示转换，否则报错
boolean flag = true;
a = flag; // 编译失败：类型不兼容
flag = a; // 编译失败：类型不兼容

下面这道题可以试着理解一下 

经过强制类型转换以后，变量a，b的值分别为多少（ ）

short a =128；

byte b =(byte) a；

A.128 127   B.128 - 128   C.128 128   D.编译错误

将a转化为byte类型之后最大范围是127但此时是128， 

所以b变为-128，a仍为128.故本题选B

3.7类型提升 

刚刚所说的类型转换是在变量赋值的过程中进行的转换，而类型提升则是多个变量在运算过程中涉及到的类型转换

1.int与long之间，int会被提升为long

这样会导致报错，需要将最下面的int改为long

那为什么不能用int呢？因为在运算过程中会自动地将int类型往long类型转：a + b==>int + long--->long + long，它们之前是不同类型，我们需要将它们转换为相同类型后再进行计算，所以需要将小类型的int转换为大类型的long，此时c就变为long类型，所以上述程序报错

2.int与double,int会转换为double

int和double进行计算时，也会进行类型提升，将b转换为double类型，同理float和double也会涉及

注意：只要有一个操作数是double另一个也会自动提升为double

3.byte与byte

如果仍然想转为byte类型，就要进行强制转换为byte类型。

也可直接将c 前的类型改为int类型。

4.字符串类型

1.定义字符串类型变量 

        String s = "hello";//String一定是大写
        System.out.println(s);
        System.out.println(s.length());//求字符串长度

2.类型转换

        //将int转成string
        int a =(int)"10";//不能将字符串类型强制转化为int类型,这个写法是错误的
        //方法一：可以直接使用+将int类型和string类型相加得到的结果是字符串
        String s = 10+"";
        System.out.println(s);
        //方法二：使用valueOf
        String s2=String.valueOf(10);//括号里只输入整数10即可
        System.out.println(s2);
        //这样就将int类型转成了String类型
        
        //将String转成int
        String t = "10";
        int b =Integer.parseInt(t);
        System.out.println(b);//此时得出来的时就是整数10
        //将String转成double
        double c=Double.parseDouble(t);
        //将String转成long
        long d = Long.parseLong(t)

三、运算符 

在学习操作符之前，我们先了解一下什么是运算符，就是对操作数进行操作的符号，像+、-等符号，Java中的运算符可分为以下：

算术运算符(+ - * / %)

关系运算符(< > == !=)

逻辑运算符(& || !)

位运算符(& | ~)

移位运算符(<<  >>)

条件运算符(?:)

1.算术运算符

1.1. 基本四则运算符：加减乘除模(+ - * / %）

        int a=10;
        int b=20;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a%b);
        System.out.println(a/b);//因为两数都为整数类型，所以得出的数要取整，为0
        //如果想要打印出数学中的结果，其中至少要有一个浮点数
        double d = a*1.0/b;//而a*1.0就相当于前面的类型提升，将a变为double类型
        System.out.println(d);

1.注意：在进行除法运算或是取余运算时，要右操作数不能为0

否则会导致异常，会使程序崩溃，不继续执行

注意：异常不等于编译出错

编译出错是自己能遇到的问题，运行的异常时到了别人使用的时候，可能遇到的问题

如果double为0时

int a=10;
double b=0;
System.out.println(a/b);//结果为Infinity（无穷大）
System.out.println(a%b);//结果为NaN（不是一个数字）

2.% 不仅可以对整型取模，也可以对double类型取模（c语言不可以），但是没有意义，一般都是对整型取模的

System.out.println(11.5 % 2.0);
//结果为1.5

3.两侧操作数类型不一致时，向类型大的提升 

System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
// 故：输出1.2

1.2. 增量运算符 （+= -= *= /= %=）

 int a=2;
 a+=3;//相当于a=a+3
 a-=3;//相当于a=a-3
 a*=3;//相当于a=a*3
 a/=3;//相当于a=a/3
 a%=3;//相当于a=a%3

注意：只有变量才能使用该运算符，常量不能使用。

1.3自增/自减运算符 （++ --）

int a = 1;
a++; // 后置++ 相当于a=a+1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，所以打印结果为2，表示式结束时给变量+1
//此式子结束时，a=3,下方验证
System.out.println(a); // 输出3

++a; // 前置++ 表示给a的值加1,相当于a=a+1=3+1,此时a为4
System.out.println(++a); // 注意：前置++是先给变量+1,即为4+1=5，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似

结论：1.  a++:先赋值，后自增

                ++a:先自增，后赋值

           2.只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

2.关系运算符 （== != < > <= >=）

 关系运算符主要有六个: == != < > <= >= ，其计算结果一定是布尔类型，为 true 或者 false，

一定要注意没有true对于1，false对于0这种写法 。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

注意：不能像数学中连续判断，需要分开写，例如下方

int a=10;
int b=20;
int c=30;
System.out.println(a<b<c);

解释：因为程序从左至右执行，先进行a<b的判断，结果我布尔类型的true，但是布尔类型不能比较大小，所以不能计算 

 3. 逻辑运算符(&& || !)

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型，操作数也是布尔类型。

3.1逻辑与---&&

表达式1&&表达式2

注意：表达式最后计算的结果必须是布尔类型

        int a=10;
        int b=20;
        int c=30;
        System.out.println(!a<b);//不能这样，表达式必须为布尔类型（true或false）
        System.out.println(!(a>b));//正确写法

左右两边同时为真才为真，只要有一个假则为假（一假则假，全真才真）

相当于现实中的且字

3.2逻辑或--||

表达式1&&表达式2

注意：与&&相同，表达式最后计算的结果必须是布尔类型

左右两边同时为假才为假只要有一个真则为真 （一真则真，全假才假）

相当于现实中的或字

3.3 逻辑非 ! 

！表达式（只有一个操作数）

真变假，假变真

！的优先级更高，需加上括号

3.4. 短路求值 

• 计算&&，只要左侧表达式为false结果一定是false右侧表达式就可以不用算了
• 计算||，只要左侧表达式为true结果一定是true右侧表达式就可以不用算了 

 System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
 //  因为/表达式右边不能为零 ,但此题表达式右边为零 所以结果应该会出现异常 但此程序结果为false,未出现异常，意味着右边并没有执行，因为左边已经为假了，结果一定为假就不用再执行右边了 
 System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
 //此题同理，左边为真就不用再执行右边了，所以会打印出true  

注意：& 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值 

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

4. 位运算符 （& | ~ ^）

 4.1按位与---&

 int a = 0xa;//16进制为a,十进制为10,二进制为1010
 int b = 0xc;
 System.out.println(a);//默认十进制和换行
 System.out.printf("%x\n",a);//将ln换位f 可以打印出我们想要的进制
 System.out.printf("0x%x\n",a);//可以在前面加上0x更加方便阅读
 System.out.printf("0x%x\n",a&b);//打印结果为16进制的8

转化过程中先将16进制换成10进制

a*10^0=10*10^0=10

再将10换为二进制 

所以8+2等于10,即后四位为1010

也可在开始菜单中找到计算器,将标准切换为程序员模式,进行计算

从上到下依次为十六进制,十进制,八进制,二进制

点击想要换算的进制来计算(我想换算16进制的A,所以点击的HEX)

上下全为1才为1,只要有0则为0

4.2按位或---|

与按位与类似

 上下全为0才为0,只要有1则为1

int a = 0xa;
int b = 0xc;
System.out.printf("0x%x\n",a|b);

4.3按位取反---~

只有一个操作数所有的0会变成1,所有的1会变成0

a是int类型,总共32位

int a = 0xa;
int b = 0xc;
System.out.printf("0x%x\n",~a);//结果为0xfffffff5

4.4按位异或---^

上下两个数相同结果为0 , 两个数不同结果为1 

 int a = 0xa;
 int b = 0xc;
 System.out.printf("0x%x\n",b^a);//结果为0x6

5. 移位运算(<< >> >>> )

5.1左移运算符 <<

移位规则：左边丢弃，右边补0。

 int a=0x10;//对应十进制为16,二进制为0001 0000
 System.out.printf("0x%x\n",a<<1);//二进制左移一位变成0010 0000,十进制为32,对应16进制为20
 int b=10;//10的二进制是00001010

 5.2右移运算符 >>和(>>>)

无符号右移(逻辑右移)：与左移相似（左边用0填充，右边丢弃）>>>

算术右移：左边用符号位填充，右边丢弃>>

下图中使用-10来举例

6. 条件运算符

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;

int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + ((b - a) >> 1);
System.out.println(c);

if(布尔表达式){
// 语句
}

int score = 60;
if(score >= 60){
    System.out.println("及格");
}

if(布尔表达式){
// 语句1
}else{
// 语句2
}

int score = 60;
if(score >= 60){
    System.out.println("及格");
}else{
    System.out.println("不及格");
}

if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
// 语句2
}else{
// 语句3
}

int score = 76;
if(score >= 90){
    System.out.println("及格");
}else if(score >= 80){
    System.out.println("良好");
}else if(score >= 70){
    System.out.println("中等");
}else if(score >= 60){
    System.out.println("及格");
}else{
    System.out.println("不及格");
}

if(score >= 90){
System.out.println("优秀");
}else if(score >= 80 && score < 90){
System.out.println("良好");
}else if(score >= 70 && score < 80){
System.out.println("中等");
}else if(score >= 60 && score < 70){
System.out.println("及格");
}else if(score >= 0 && score < 60){
System.out.println("不及格");
}else{
System.out.println("错误数据");
}

int num=9;
if(num%2==1){
    System.out.println("num是奇数");
}else {
    System.out.println("num是偶数");
}

int num = -1;
if(num<0){
    System.out.println("num是负数");
}else if(num>0){
    System.out.println("num是正数");
}else{
    System.out.println("num是零");
}

 System.out.println("请输入一个整数  ");
 Scanner scanner = new Scanner(System.in);
 int num =scanner.nextInt();
 if(num<0){
     System.out.println("num是负数");
 }else if(num>0){
     System.out.println("num是正数");
 }else{
     System.out.println("num是零");
 }

System.out.println("请输入一个整数  ");
Scanner scanner = new Scanner(System.in);
int year = scanner.nextInt();
if (year % 100 == 0) {
    if (year % 400 == 0) {
        System.out.println(year + "是闰年");
    } else {
        System.out.println(year + "不是闰年");
    }
} else {
    if (year % 4 == 0) {
        System.out.println(year + "是闰年");
    } else {
        System.out.println(year + "不是闰年");
    }
}

int x = 20;
if (x == 10); 
{
    System.out.println("hello");
}
 
// 运行结果
hello

悬垂else问题:

int x = 10;
int y = 10;
if (x == 10)
if (y == 10)
System.out.println("aaa");
else
System.out.println("bbb");

//因为0.1加0.2不能精确的等于0.3所以说 我们要是用判断a加B是否等于0.3的方法是不可取的
// 一般不是直接比较浮点数相等,而后是做减法,判断差值是否在规定的误差范围之内   
double gap=0.00000001;
double a=0.1;
double b=0.2;
if((a+b-0.3<gap)&&(a+b-0.3>-gap)){
    System.out.println("相等");
}else{
    System.out.println("不相等");
}

switch(表达式){
case 常量值1:{
语句1;
[break;]
}
case 常量值2:{
语句2;
[break;]
}
...
default:{
内容都不满足时执行语句;
[break;]
}
}

System.out.println("请输入一个整数  ");
Scanner scanner = new Scanner(System
int day = scanner.nextInt();
switch(day){
    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;
    case 7:
        System.out.println("星期日");
        break;
    default:
        System.out.println("输入有误");
        break;//由于default是最后一个所以说是否有break都无所谓 
}

3.循环结构

3.1while语句

while(循环条件){
循环语句;
}

 循环条件为 true, 则执行循环语句; 否则结束循环.

练习

练习1:打印 1 - 10 的数字

int i=1;
while(i<=10){
    System.out.println(i);
    i++;
}

练习2: 计算 1 - 100 的和

 int i=1,sum=0;
 while(i<=100){
     sum=sum+i;
     i++;
 }
     System.out.println(sum);

练习3:计算五的阶乘 

int i=1,s=1;
while(i<6){
    s=s*i;
    i++;
}
System.out.println(s);

练习4：计算 1!+2!+3!+4!+5!

int i=1,s=1,sum=0,n=1;
while(i<=5){
    while (i <= n) {//第几个数n就为几
        s = s * i;
        i++;
    }//先算出每一项的阶乘
    sum=s+sum;//最后再求和
    n++;
}
System.out.println(sum);

int sum=0,n=1;
while(n<=5){
    int i=1,s=1
    while (i <= n) {//第几个数n就为几
        s = s * i;
        i++;
    }//先算出每一项的阶乘
    sum=s+sum;//最后再求和
    n++;
}
System.out.println(sum);

练习5:输出 1000 - 2000 之间所有的闰年

int year = 1000;
while (year >= 1000 && year <= 2000) {
    if (year % 100 == 0) {
        if (year % 400 == 0) {
            System.out.println(year);
        } else {
        }
    } else {
        if (year % 4 == 0) {
            System.out.println(year);
        }else{
        }
    }
    year++;
}

3.2.break与continue

• break:结束当前整个循环语句,不会继续进行循环 
• continue:立即结束当前这一循环 , 直接进入到下一次循环的条件判断 

eg:打印出零到一百之间能被五整除的数字 

1.break

结果只能打印第一个数字零因为遇到break就会跳出循环,不会再进行 

2.continue

注意:遇到continue之后不会执行下方的打印语句,而是直接进入下次循环(判定循环条件) 

3.3for循环 

for ( 表达式① ; 布尔表达式② ; 表达式③ ){

表达式④ ;

}

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

int j=0;
while(j<=10){
    System.out.println(j);
    j++;
}

//注意:在for循环中
//省略for括号内的三个条件任意一个或两个或三个都可以,大家要注意如何修改 
int i=0;//此条件可以放在循环外面
for(;i<=10;){//;留下 
    System.out.println(i);
    i++;//此条件也可拿出放在最后一行(循环里)
}


//也可以将表达式二放在循环里
for(int i=0;;i++){
    if(i>100){
     break;
     }
    sum=sum+i;
    System.out.println(i);
}

//三个都省略的程序为下 
int sum=0;
int i=0;
for(;;){
    if(i>10){
        break;
    }
    sum=sum+i;
    System.out.println(i);
    i++;
}

注意:表达式1中定义的变量只能在此循环中使用 . 如下图可见:此方块以外的s都会显示未被定义  

练习: 

练习1:计算 1 - 100 的和

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

练习2: 计算5的阶乘

int s=1;
for(int i=1;i<=5;i++){
    s=s*i;
}
System.out.println(s);

练习3: 计算 1! + 2! + 3! + 4! + 5!

在这道题中我们涉及到了嵌套循环 ,需要注意一点的是 

当其中一个for循环位于另外一个for循环里面时 , 定义的变量不可以相同 , 但如果每一个for循环都是一个独立的整体时 , 它们定义的变量是可以相同的 

 结果为:

int n=1;
int sum=0;
for(int i=1;i<=5;i++) {
    int s = 1;
    for (int j = 1; j <= i; j++) {
        s = s * j;
    }
    sum=sum+s;
}
System.out.println(sum);

3.4.do while循环

do{
循环语句;
}while(循环条件);

先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束

//打印1-10
int num = 1;
do {
System.out.println(num);
num++;
} while (num <= 10);

不是很常用 , 建议使用for循环和while循环  

 练习:

1.判定一个数字是否是素数 

Java---判断素数的三种方法-CSDN博客

2.求出0-999之间的所有水仙花数,并输出

(水仙花数是指 : 一个三位数其各位数字的立方和恰好等于该数本身)

public class Text {
    public static void main(String[] args) {
        for(int i=100;i<=999;i++){
            int a = i%10;
            int b = (i/10)%10;
            int c = i/100;
            if(a*a*a+b*b*b+c*c*c==i){
                System.out.println(i+"是水仙花数");
            }
        }
    }
}

五.输入输出

1.输出到控制台

        for (int i = 1; i <= 3; i++) {
            System.out.println(i);
            //println自动换行
            //java,println本质上是打印字符串string ,把int和String进行+,直接把int转成String
        }
        for (int i = 1; i <= 3; i++) {
            System.out.print(i);
            //print打印不换行
        }

        System.out.println("\n");

        for (int i = 1; i <= 3; i++) {
            System.out.print(i+"\n");
            //print打印不换行,除非手写\n(i+"\n")
        }

        System.out.println("接下来我们来看printf");
        for (int i = 0; i <= 3; i++) {
            System.out.printf("%d", i);
            //格式化打印,与c语言相似

从上方我们可以看出println能自动添加换行而print就不能

printf的输出格式与C语言相似都是格式化打印并且想要添加换行

也需要手动添加"%d\n"

2 从键盘输入

键盘输入代码的四个步骤:
1、建立导包：import java.util.Scanner;

三种方法:

• 直接输入到最上方
• 输入Scan+ Tab键
• 可以在输入完Scanner scanner= new Scanner( System.in) 之后将光标放在标红处,点击Alt+Enter

2、创建Scanner类型的对象：Scanner scanner= new Scanner( System.in) ;
3、调用Scanner类的相关方法(next() / nextXxx()) ，来获取指定类型的变量
4.结尾调用关闭方法： scanner.close();                       

2.1使用 Scanner 读取字符串/整数/浮点数

1.字符串:next

2.一行nextLine

3.float:  nextFloat

4.double:  nextDouble 

5.整数:  nextInt

6.byte:  nextByte

7.short:  nextShort

8.long:  nextLong

9.布尔类型:  nextBoolean

2.1.1一般写法 

直接按照步骤往下写 , 不用判断类型是否一致 , 类型不一致会自动报错 

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = scanner.nextLine();

        System.out.println("请输入你的年龄：");
        int age = scanner.nextInt();

        System.out.println("请输入你的工资：");
        float salary = scanner.nextFloat();

        System.out.println("你的信息如下：");
        System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
        scanner.close(); // 注意, 要记得调用关闭方法
        }
    }


请输入你的姓名：
张三
请输入你的年龄：
18
请输入你的工资：
1000
你的信息如下：
姓名: 张三
年龄：18
工资：1000.0

Scanner scanner = new Scanner(System.in);
if(scanner.hasNextInt()) {//先判断一下有没有数据可读
    int n = scanner.nextInt();//if后的真假是由所输入的内容和括号内的类型是否一样来判别的
    System.out.println(n);
}else{
    System.out.println("输入有误");
}

Scanner scanner = new Scanner(System.in);
int num=0;//总和
int count = 0;//变量个数
double a=0.0;
System.out.println("请输入整数:  ");
while(scanner.hasNextInt()) {//先判断一下有没有数据可读
    int n = scanner.nextInt();
    num=num+n;
    count++;
}
    a=num/count;
    System.out.println("平均数为"+a);

总结

以上就是今天要讲的内容，本文详细介绍了Java的基础语法