Java基础入门（一）

最新推荐文章于 2024-05-11 15:19:02 发布

校生兄

最新推荐文章于 2024-05-11 15:19:02 发布

阅读量1.4k

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq2835483738/article/details/117897552

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第一章开发前言

1.1 Java语言概述

什么是java语言？

Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。所谓编程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。

Java语言发展历史

1995年Sun公司发布Java1.0版本
1997年发布Java 1.1版本
1998年发布Java 1.2版本
2000年发布Java 1.3版本
2002年发布Java 1.4版本
2004年发布Java 1.5版本
2006年发布Java 1.6版本
2009年Oracle甲骨文公司收购Sun公司，并于2011发布Java 1.7版本
2014年发布Java 1.8版本
2017年发布Java 9.0版本

Java语言能做什么

Java语言主要应用在互联网程序的开发领域。常见的互联网程序比如天猫、京东、物流系统、网银系统等，以及服

务器后台处理大数据的存储、查询、数据挖掘等也有很多应用。

在这里插入图片描述

1.2 计算机基础知识

二进制

计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用二进制数表示，它只包含

0、1两个数，逢二进一，1+1=10。每一个0或者每一个1，叫做一个bit（比特）。

下面了解一下十进制和二进制数据之间的转换计算。

**十进制数据转成二进制数据：**使用除以2获取余数的方式

在这里插入图片描述

**二进制数据转成十进制数据：**使用8421编码的方式

在这里插入图片描述

小贴士：二进制数系统中，每个0或1就是一个位，叫做bit（比特）。

字节

字节是我们常见的计算机中最小存储单元。计算机存储任何的数据，都是以字节的形式存储，右键点击文件属性，

我们可以查看文件的字节大小。

8个bit（二进制位） 0000-0000表示为1个字节，写成1 byte或者1 B。

8 bit = 1 B
1024 B =1 KB
1024 KB =1 MB
1024 MB =1 GB
1024 GB = 1 TB

常用DOS命令

Java语言的初学者，学习一些DOS命令，会非常有帮助。DOS是一个早期的操作系统，现在已经被Windows系统取代，对于我们开发人员，目前需要在DOS中完成一些事情，因此就需要掌握一些必要的命令。

进入DOS操作窗口
- 按下Windows+R键盘，打开运行窗口，输入cmd回车，进入到DOS的操作窗口

在这里插入图片描述

打开DOS命令行后，看到一个路径 c:\user 就表示我们现在操作的磁盘是c盘。

在这里插入图片描述

常用命令

命令	操作符号
盘符切换命令	盘符名:
查看当前文件夹	dir
进入文件夹命令	cd 文件夹名
退出文件夹命令	cd…
退出到磁盘根目录	cd\
清屏	cls

第二章 Java语言开发环境搭建

2.1 Java虚拟机——JVM

JVM（Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的

运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM 之上。
跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系

统上，这个特性称为Java语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM 运行在操作系统上。

在这里插入图片描述

如图所示，Java的虚拟机本身不具备跨平台功能的，每个操作系统下都有不同版本的虚拟机。

2.2 JRE 和 JDK

JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含 JVM 和运行时所需要的核心类库。
JDK (Java Development Kit)：是Java程序开发工具包，包含 JRE 和开发人员使用的工具。

我们想要运行一个已有的Java程序，那么只需安装 JRE 即可。

我们想要开发一个全新的Java程序，那么必须安装 JDK 。

小贴士：三者关系： JDK > JRE > JVM

2.3 JDK9安装图解

在这里插入图片描述

小贴士：安装路径中，不要包含中文和空格。

2.4 JAVA_HOME环境变量的配置

配置环境变量作用

开发Java程序，需要使用JDK中提供的工具，工具在JDK9安装目录的 bin 目录下。

配置环境变量步骤

计算机鼠标右键,选择属性

在这里插入图片描述

选择高级系统设置

在这里插入图片描述

高级选项卡，点击环境变量

在这里插入图片描述

点击新建，创建新的环境变量

在这里插入图片描述

变量名输入 JAVA_HOME ，变量值输入JDK9的安装目录 c:\Java9\jdk-9.0.1
选中 Path 环境变量，双击或者点击编辑

在这里插入图片描述

在变量值的最前面，键入 %JAVA_HOME%\bin; 分号必须要写，必须是英文格式。

在这里插入图片描述

环境变量配置完成，重新开启DOS命令行，在任意目录下输入 javac 命令，运行成功。

在这里插入图片描述

第三章 HelloWorld入门程序

3.1 程序开发步骤说明

开发环境已经搭建完毕，可以开发我们第一个Java程序了。

Java程序开发三步骤：编写、编译、运行。

在这里插入图片描述

3.2编写Java源程序

在 d:\day01 目录下新建文本文件，完整的文件名修改为 HelloWorld.java ，其中文件名为 HelloWorld ，后

缀名必须为 .java 。

用记事本notepad++打开
在文件中键入文本并保存，代码如下：

public class HelloWorld { 
    public static void main(String[] args) { 
        System.out.println("Hello World!"); 
    } 
}

文件名必须是 HelloWorld ，保证文件名和类的名字是一致的，注意大小写。

每个字母和符号必须与示例代码一模一样。

第一个 HelloWord 源程序就编写完成了，但是这个文件是程序员编写的，JVM是看不懂的，也就不能运行，因此我们必须将编写好的 Java源文件编译成JVM可以看懂的字节码文件。

3.3 编译Java源文件

在DOS命令行中，进入Java源文件的目录，使用 javac 命令进行编译。

javac Java源文件名.后缀名
如:    
javac HelloWorld.java

在这里插入图片描述

编译成功后，命令行没有任何提示。打开 d:\day01目录，发现产生了一个新的文件 HelloWorld.class，该文件就是编译后的文件，是Java的可运行文件，称为字节码文件，有了字节码文件，就可以运行程序了。

Java源文件的编译工具 javac.exe ，在JDK安装目录的bin目录下。但是由于配置了环境变量，可以再任意目

录下使用。

3.4 运行Java程序

在DOS命令行中，进入Java源文件的目录，使用 java 命令进行运行。

java 类名字
如:
java HelloWorld 不要写class

在这里插入图片描述

Java程序 .class文件的运行工具 java.exe ，在JDK安装目录的bin目录下。但是由于配置了环境变量，可

以再任意目录下使用。

3.5 入门程序说明

编译和运行是两回事

编译：是指将我们编写的Java源文件翻译成JVM认识的class文件，在这个过程中，javac 编译器会检查我们

所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。
运行：是指将 class文件交给JVM去运行，此时JVM就会去执行我们编写的程序了。

关于main方法

main方法：称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序，JVM在运行的时候，都会从main方法这里开始执行。

3.6 添加注释comment

注释：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须

要的，它不影响程序的编译和运行。
Java中有单行注释、多行注释和文档注释

单行注释以//开头换行结束

多行注释以/*开头以*/结束

文档注释以/**开头 */结束

3.7 关键字keywords

关键字：是指在程序中，Java已经定义好的单词，具有特殊含义。
- HelloWorld案例中，出现的关键字有 public 、 class 、 static 、 void 等，这些单词已经被
  
  Java定义好，全部都是小写字母，notepad++中颜色特殊。
- 关键字比较多，不能死记硬背，学到哪里记到哪里即可。

3.8 标识符

标识符：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。
- HelloWorld案例中，出现的标识符有类名字 HelloWorld 。
命名规则： 硬性要求
- 标识符可以包含英文字母26个(区分大小写) 、 0-9数字、 $（美元符号）和 _（下划线）。
- 标识符不能以数字开头。
- 标识符不能是关键字。
命名规范： 软性建议
- 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
- 方法名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。
- 变量名规范：与方法名相同。

第四章常量

4.1 概述

常量：是指在Java程序中固定不变的数据。

4.2 分类

类型	含义	数据举例
整数常量	所有的整数	0，1， 567， -9
小数常量	所有的小数	0.0， -0.1， 2.55
字符常量	单引号引起来,只能写一个字符,必须有内容	‘a’ ， ’ ‘， ‘好,’/u0000’
字符串常量	双引号引起来,可以写多个字符,也可以不写	“A” ，“Hello” ，“你好” ，""
布尔常量	只有两个值（流程控制中讲解）	true ， false
空常量	只有一个值（引用数据类型中讲解）	null

4.3 练习

public class ConstantDemo { 
    public static void main(String[] args){ 
        //输出整数常量 
        System.out.println(123);
        //输出小数常量 
        System.out.println(0.125); 
        //输出字符常量
        System.out.println('A'); 
        //输出布尔常量
        System.out.println(true);
        //输出字符串常量 System.out.println("你好Java");
    }
}

第五章变量和数据类型

5.1 变量概述

变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。

数学中，可以使用字母代替数字运算,例如 x=1+5 或者 6=x+5。

程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如x保存5，x也可

以保存6，这样x保存的数据是可以改变的，也就是我们所讲解的变量。

Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。

5.2 数据类型

数据类型分类

Java的数据类型分为两大类：

基本数据类型：包括 整数 、 浮点数 、 字符、 布尔 。
引用数据类型：包括类 、 数组、 接口。

基本数据类型

四类八种基本数据类型：

数据类型	关键字	内存占用	取值范围
字节型	byte	1字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-231次方~2的31次方-1
长整型	long	8个字节	-2的63次方~2的63次方-1
单精度浮点数	float	4个字节	1.4013E-45~3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	true，false

5.3 变量的定义

变量定义的格式包括三个要素：数据类型 、 变量名 、 数据值 。

格式

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

练习

定义所有基本数据类型的变量，代码如下：

public class Variable { 
    public static void main(String[] args){
        //定义字节型变量 
        byte b = 100;
        System.out.println(b); 
        //定义短整型变量
        short s = 1000;
        System.out.println(s); 
        //定义整型变量 int i = 123456;
        System.out.println(i); 
        //定义长整型变量 
        long l = 12345678900L;
        System.out.println(l); 
        //定义单精度浮点型变量
        float f = 5.5F;
        System.out.println(f); 
        //定义双精度浮点型变量
        double d = 8.5;
        System.out.println(d); 
        //定义布尔型变量
        boolean bool = false;
        System.out.println(bool); 
        //定义字符型变量 char c = 'A'; 
        System.out.println(c); 
    }
}

long类型：建议数据后加L表示。

float类型：建议数据后加F表示。

5.4 注意事项

变量名称：在同一个大括号范围内，变量的名字不可以相同
变量赋值：定义的变量，不赋值不能使用。

第六章数据类型转换

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

6.1 自动转换

一个int 类型变量和一个byte 类型变量进行加法运算，结果会是什么数据类型？

int i = 1; byte b = 2;

运算结果，变量的类型将是 int 类型，这就是出现了数据类型的自动类型转换现象。

自动转换：将取值范围小的类型自动提升为取值范围大的类型。

public static void main(String[] args) { 
    int i = 1;
    byte b = 2;
    // byte x = b + i; // 报错 
    //int类型和byte类型运算，结果是int类型
    int j = b + i; 
    System.out.println(j);
}

转换原理图解

byte 类型内存占有1个字节，在和 int 类型运算时会提升为int类型，自动补充3个字节，因此计算后的结果还是 int 类型。

在这里插入图片描述

同样道理，当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。

public static void main(String[] args) { 
    int i = 1; double d = 2.5; 
    //int类型和double类型运算，结果是double类型
    //int类型会提升为double类型
    double e = d+i; 
    System.out.println(e);
}

转换规则

范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

6.2 强制转换

将 1.5赋值到 int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 1.5; // 错误

double类型内存8个字节，int类型内存4个字节。 1.5 是 double类型，取值范围大于int 。可以理解为 double 是8升的水壶， int 是4升的水壶，不能把大水壶中的水直接放进小水壶去。

想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成int类型才能赋值。

强制类型转换：将取值范围大的类型强制转换成取值范围小的类型。

比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

转换格式：

数据类型 变量名 = （数据类型）被转数据值；
//将 1.5 赋值到 int 类型，代码修改为：
// double类型数据强制转成int类型，直接去掉小数点。
int i = (int)1.5;

同样道理，当一个short类型与 1 相加，我们知道会类型提升，但是还想给结果赋值给short类型变量，就需要强制转换。

public static void main(String[] args) { 
    //short类型变量，内存中2个字节
    short s = 1;
    /*出现编译失败 s和1做运算的时候，1是int类型，s会被提升为int类型 s+1后的结果是int类型，将结果在赋值会short类型时发生错误 short内存2个字节，int类型4个字节 必须将int强制转成short才能完成赋值 */
    s = s + 1；//编译失败
    s = (short)(s+1);//编译成功
}

转换原理图解

在这里插入图片描述

强烈注意

浮点转成整数，直接取消小数点，可能造成数据损失精度。
int强制转成 short 砍掉2个字节，可能造成数据丢失。

// 定义s为short范围内最大值 
short s = 32767; 
// 运算后，强制转换，砍掉2个字节后会出现不确定的结果 
s = (short)(s + 10);

6.3 ASCII编码表

public static void main(String[] args) { 
    //字符类型变量 
    char c = 'a';
    int i = 1; 
    //字符类型和int类型计算 
    System.out.println(c+i);//输出结果是98 
}

在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。

编码表 ：就是将人类的文字和一个十进制数进行对应起来组成一张表格。

在这里插入图片描述

将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII（

American Standard Code for Information Interchange 美国标准信息交换码）

在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。

第七章运算符

7.1 算数运算符

算数运算符包括：
+	加法运算，字符串连接运算
-	减法运算
*	乘法运算
/	除法运算
%	取模运算，两个数字相除取余数
++ 、 –	自增自减运算

Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。

public static void main(String[] args) { 
    int i = 1234;
    System.out.println(i/1000*1000);//计算结果是1000
}

++ 运算，变量自己增长1。反之， – 运算，变量自己减少1，用法与 ++ 一致。
- 独立运算：
  - 变量在独立运算时，前++和后++没有区别。
  - 变量前++：例如 ++i。
  - 变量后++ ：例如i++ 。
- 混合运算：
  - 和其他变量放在一起，前++ 和后++就产生了不同。
  - 变量前++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

public static void main(String[] args) { 
    int a = 1; 
    int b = ++a;
    System.out.println(a);//计算结果是2
    System.out.println(b);//计算结果是2 
}

变量后++ ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b

的结果是1。

public static void main(String[] args) { 
    int a = 1; 
    int b = a++;
    System.out.println(a);//计算结果是2 
    System.out.println(b);//计算结果是1 
}

+ 符号在字符串中的操作：
- + 符号在遇到字符串的时候，表示连接、拼接的含义。
- “a”+"b"的结果是“ab”，连接含义

public static void main(String[] args){
    System.out.println("5+5="+5+5);//输出5+5=55 
}

7.2 赋值运算符

赋值运算符包括：
=	等于号
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	取模等

赋值运算符，就是将符号右边的值，赋给左边的变量。

public static void main(String[] args){ 
    int i = 5;
    i+=5;//计算方式 i=i+5 变量i先加5，再赋值变量i 
    System.out.println(i); //输出结果是10
}

7.3 比较运算符

比较运算符包括：
==	比较符号两边数据是否相等，相等结果是true。
<	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=	比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。
>=	比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true
！=	不等于符号，如果符号两边的数据不相等，结果是true。

比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。

public static void main(String[] args) { 
    System.out.println(1==1);//true 
    System.out.println(1<2);//true 
    System.out.println(3>4);//false 
    System.out.println(3<=4);//true 
    System.out.println(3>=4);//false 
    System.out.println(3!=4);//true 
}

7.4 逻辑运算符

逻辑运算符包括：
&& 短路与	1. 两边都是true，结果是true2. 一边是false，结果是false,短路特点：符号左边是false，右边不再运算
\|\| 短路或	1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点：符号左边是true，右边不再运算
！取反	1. ! true 结果是false 2. ! false结果是true

逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false

public static void main(String[] args) { 
    System.out.println(true && true);//true
    System.out.println(true && false);//false
    System.out.println(false && true);//false，右边不计算 
    System.out.println(false || false);//falase 
    System.out.println(false || true);//true 
    System.out.println(true || false);//true，右边不计算 
    System.out.println(!false);//true 
}

7.5 三元运算符

三元运算符格式：

数据类型 变量名 = 布尔类型表达式？结果1：结果2

三元运算符计算方式：
- 布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
- 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) { 
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500 
}

第八章方法入门

8.1 概述

我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

8.2 方法的定义

定义格式：

修饰符 返回值类型 方法名 （参数列表）｛ 代码... return ; ｝

定义格式解释：
- 修饰符：目前固定写法 public static 。
- 返回值类型：目前固定写法 void ，其他返回值类型在后面的课程讲解。
- 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。
- 参数列表：传入方法的参数
- return：方法结束。因为返回值类型是void，方法大括号内的return可以不写。
举例：

public static void methodName() { 
    System.out.println("这是一个方法"); 
}

8.3 方法的调用

方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。

public static void main(String[] args) { 
    //调用定义的方法method 
    method(); }
    //定义方法，被main方法调用 
public static void method() { 
    System.out.println("自己定义的方法，需要被main调用运行"); 
}

8.4 调用练习

将三元运算符代码抽取到自定义的方法中，并调用。

public static void main(String[] args) { 
    //调用定义的方法
    operator operator();
}//定义方法，方法中定义三元运算符
public static void operator() { 
    int i = 0; i = (1==2 ? 100:200); 
    System.out.println(i); 
    int j = 0 ; j = (3<=4 ? 500:600);
    System.out.println(j);
}

8.5 注意事项

方法定义注意事项：
- 方法必须定义在一类中方法外
- 方法不能定义在另一个方法的里面

public class Demo {
    public static void main(String[] args){
    }//正确写法，类中，main方法外面可以定义方法 
    public static void method(){     
    }
}

public class Demo {
    public static void main(String[] args){ 
        //错误写法，一个方法不能定义在另一方法内部 
        public static void method(){} 
    }
}

第九章流程控制

9.1 概述

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果

有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现

我们要完成的功能。

9.2 顺序结构

public static void main(String[] args){ 
    //顺序执行，根据编写的顺序，从上到下运行 
    System.out.println(1);
    System.out.println(2);
    System.out.println(3);
}

9.3 判断语句1–if

if语句第一种格式: if

if(关系表达式)｛
语句体; 
｝

执行流程
- 首先判断关系表达式看其结果是true还是false
- 如果是true就执行语句体
- 如果是false就不执行语句体

在这里插入图片描述

public static void main(String[] args){ 
    System.out.println("开始"); 
    // 定义两个变量
    int a = 10; 
    int b = 20; 
    //变量使用if判断 
    if (a == b){ 
        System.out.println("a等于b");
    }
    int c = 10; 
    if(a == c){
        System.out.println("a等于c");
    }System.out.println("结束"); 
}

9.4 判断语句2–if…else

if语句第二种格式： if…else

if(关系表达式) { 
    语句体1; 
}else { 
    语句体2; 
}

执行流程
- 首先判断关系表达式看其结果是true还是false
- 如果是true就执行语句体1
- 如果是false就执行语句体2

public static void main(String[] args){ 
    // 判断给定的数据是奇数还是偶数
    // 定义变量 
    int a = 1; 
    if(a % 2 == 0) {
        System.out.println("a是偶数");
    } else{ 
        System.out.println("a是奇数");
    }
    System.out.println("结束");
}

9.5 判断语句3–if…else if…else

**if语句第三种格式：**if…else if …else

if (判断条件1) { 
    执行语句1;
} else if (判断条件2) { 
    执行语句2; 
}... 
}else if (判断条件n) { 
    执行语句n; 
} else { 
    执行语句n+1;
}

执行流程
- 首先判断关系表达式1看其结果是true还是false
- 如果是true就执行语句体1
- 如果是false就继续判断关系表达式2看其结果是true还是false
- 如果是true就执行语句体2
- 如果是false就继续判断关系表达式…看其结果是true还是false
- …
- 如果没有任何关系表达式为true，就执行语句体n+1。

在这里插入图片描述

public static void main(String[] args) { 
    // x和y的关系满足如下：
    // x>=3 y = 2x + 1; 
    //‐1<=x<3 y = 2x; 
    // x<=‐1 y = 2x – 1;
    // 根据给定的x的值，计算出y的值并输出。 
    // 定义变量 
    int x = 5; int y; 
    if (x>= 3) {
        y = 2 * x + 1; 
    } else if (x >= ‐1 && x < 3) { 
        y = 2 * x;
    } else {
        y = 2 * x ‐ 1;
    }
    System.out.println("y的值是："+y); 
}

9.6 语句练习

指定考试成绩，判断学生等级
- 90-100 优秀
- 80-89 好
- 70-79 良
- 60-69 及格
- 60以下不及格

public static void main( String[] args) {
    int score = 100;
    if(score<e ll score>100){
    system.out.println("你的成绩是错误的");
    }else if(score>=90 88 score<=100){
    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.print1n("你的成绩属于及格");
    }else {
    system.out. print1n("你的成绩属于不及格");
    }
  }
}

9.6 if语句和三元运算符的互换

在某些简单的应用中，if语句是可以和三元运算符互换使用的。

public static void main(String[] args) { 
    int a = 10; int b = 20;
    //定义变量，保存a和b的较大值 
    int c; if(a > b) {
        c = a;
    } else {
        c = b;
    }
    //可以上述功能改写为三元运算符形式
    c = a > b ? a:b;
}

9.7 选择语句–switch

switch语句格式：

switch(表达式) {
    case 常量值1: 
         语句体1; 
         break; 
    case 常量值2:
         语句体2; 
         break;
        ...
         default:
         语句体n+1; 
         break; 
}

执行流程
- 首先计算出表达式的值
- 其次，和case依次比较，一旦有对应的值，就执行相应的语句，在执行的过程中，遇到break就会结束。
- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

在这里插入图片描述

public static void main(String[] args) { 
    //定义变量，判断是星期几 
    int weekday = 6; 
    //switch语句实现选择 
    switch(weekday) { 
        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; 
    } 
}

switch语句中，表达式的数据类型，可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。

9.8 case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运

行，直到遇到break，或者整体switch结束。

public static void main(String[] args) { 
    int i = 5; 
    switch (i){
        case 0: System.out.println("执行case0");  break; 
        case 5: System.out.println("执行case5"); 
        case 10: System.out.println("执行case10"); 
        default: System.out.println("执行default");
    } 
}

上述程序中，执行case5后，由于没有break语句，程序会一直向后走，不会在判断case，也不会理会break，直接运行完整体switch。由于case存在穿透性，因此初学者在编写switch语句时，必须要写上break。

9.9 循环概述

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复

执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

9.10 循环语句1–for

for循环语句格式：

for(初始化表达式①; 布尔表达式②; 步进表达式④){ 
    循环体③ 
}

执行流程
- 执行顺序：①②③④>②③④>②③④…②不满足为止。
- ①负责完成循环变量初始化
- ②负责判断是否满足循环条件，不满足则跳出循环
- ③具体执行的语句
- ④循环后，循环条件所涉及变量的变化情况

在这里插入图片描述

public static void main(String[] args) { 
    //控制台输出10次HelloWorld，不使用循环
    System.out.println("HelloWorld");
    System.out.println("HelloWorld"); 
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");  
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    //用循环改进，循环10次 //定义变量从0开始，循环条件为<10 
    for(int x = 0; x < 10; x++) { 
        System.out.println("HelloWorld"+x);
    } 
}

循环练习：使用循环，计算1-100之间的偶数和

public static void main(String[] args) { 
    //1.定义一个初始化变量,记录累加求和,初始值为0 
    int sum = 0; 
    //2.利用for循环获取1‐100之间的数字 
    for (int i = 1; i <= 100; i++) { 
        //3.判断获取的数组是奇数还是偶数 
        if(i % 2==0){ 
       //4.如果是偶数就累加求和 
            sum += i;
        }
    } 
    //5.循环结束之后,打印累加结果 
    System.out.println("sum:"+sum); 
}

9.11 循环语句2–while

while循环语句格式：

初始化表达式① while(布尔表达式②){ 
    循环体③ 步进表达式④ 
}

执行流程
- 执行顺序：①②③④>②③④>②③④…②不满足为止。
- ①负责完成循环变量初始化。
- ②负责判断是否满足循环条件，不满足则跳出循环。
- ③具体执行的语句。
- ④循环后，循环变量的变化情况

在这里插入图片描述

while循环输出10次HelloWorld

public static void main(String[] args) { 
    //while循环实现打印10次HelloWorld 
    //定义初始化变量 int i = 1; 
    //循环条件<=10 
    while(i<=10){ 
        System.out.println("HelloWorld"); 
        //步进 i++; 
    } 
}

while循环计算1-100之间的和

public static void main(String[] args) { 
    //使用while循环实现
    //定义一个变量,记录累加求和 
    int sum = 0; 
    //定义初始化表达式 
    int i = 1; 
    //使用while循环让初始化表达式的值变化
    while(i<=100){ 
        //累加求和 
        sum += i ;
        //步进表达式改变变量的值
        i++;
    }
    System.out.println("1‐100的和是："+sum);
}

9.12 循环语句3–do…while

do…while循环格式

初始化表达式① 
    do{ 
    循环体③ 
    步进表达式④ 
}while(布尔表达式②);

执行流程
执行顺序：①③④>②③④>②③④…②不满足为止。
- ①负责完成循环变量初始化。
- ②负责判断是否满足循环条件，不满足则跳出循环。
- ③具体执行的语句
- ④循环后，循环变量的变化情况

在这里插入图片描述

输出10次HelloWorld

public static void main(String[] args) { 
    int x=1; 
    do {
        System.out.println("HelloWorld");
        x++;
    }while(x<=10);
}

do…while循环的特点：无条件执行一次循环体，即使我们将循环条件直接写成false，也依然会循环一次。这样的

循环具有一定的风险性，因此初学者不建议使用do…while循环。

public static void main(String[] args){ 
    do{ 
        System.out.println("无条件执行一次");
    }while(false);
}

9.13 循环语句的区别

for 和 while 的小区别：
- 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继
续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消

失，能够提高内存的使用效率。
- 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

9.14 跳出语句

break

使用场景：终止switch或者循环
- 在选择结构switch语句中
- 在循环语句中
- 离开使用场景的存在是没有意义的

public static void main(String[] args) { 
    for (int i = 1; i<=10; i++) { 
        //需求:打印完两次HelloWorld之后结束循环 
        if(i == 3){ 
            break; 
        }
        System.out.println("HelloWorld"+i); 
    } 
}

continue

使用场景：结束本次循环，继续下一次的循环

public static void main(String[] args) { 
    for (int i = 1; i <= 10; i++) { 
        //需求:不打印第三次HelloWorld 
        if(i == 3){ 
            continue;
        }System.out.println("HelloWorld"+i); 
    } 
}

第十章数组

10.1 容器概述

案例分析

现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有50名员工，用前面所学的知识，程序首先需要声明50个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦，而且错误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一操作。

容器概念

**容器：**是将多个数据存储到一起，每个数据称为该容器的元素。
**生活中的容器：**水杯，衣柜，教室

10.2 数组概念

数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组的定义
方式一

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解：
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- [] : 表示数组。
- 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
- new：关键字，创建数组使用的关键字。
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- [长度]：数组的长度，表示数组容器中可以存储多少个元素。
- 注意：数组有定长特性，长度一旦指定，不可更改。
举例：

定义可以存储3个整数的数组容器，代码如下：

int[] arr = new int[3];

方式二

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

定义存储1，2，3，4，5整数的数组容器。

int[] arr = new int[]{1,2,3,4,5};

方式三

数据类型[] 数组名 = {元素1,元素2,元素3...};

定义存储1，2，3，4，5整数的数组容器

int[] arr = {1,2,3,4,5};

10.3 数组的访问

索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引

(index)，可以通过数组的索引访问到数组中的元素。
格式：

数组名[索引]

数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的

长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数

组的最大索引值为数组名.length-1 。

public static void main(String[] args) { 
    int[] arr = new int[]{1,2,3,4,5}; 
    //打印数组的属性，输出结果是5 
    System.out.println(arr.length); 
}

索引访问数组中的元素：
- 数组名[索引]=数值，为数组中的元素赋值
- 变量=数组名[索引]，获取出数组中的元素

public static void main(String[] args) {
    //定义存储int类型数组，赋值元素1，2，3，4，5
    int[] arr = {1,2,3,4,5}; 
    //为0索引元素赋值为6 
    arr[0] = 6; 
    //获取数组0索引上的元素
    int i = arr[0];
    System.out.println(i); 
    //直接输出数组0索引元素
    System.out.println(arr[0]);
}

第十一章数组原理内存图

11.1 内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程

序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

JVM的内存划分：

区域名称	作用
程序计数器	存储指向下一条指令的地址
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

11.2 数组在内存中的存储

一个数组内存图

public static void main(String[] args) {
    int[] arr = new int[3];
    System.out.println(arr);//[I@5f150435 
}

以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆

内存中存储的，而方法中的变量arr保存的是数组的地址。

输出arr[0],就会输出arr保存的内存地址中数组中0索引上的元素

在这里插入图片描述

两个数组内存图

public static void main(String[] args) {
    int[] arr = new int[3]; 
    int[] arr2 = new int[2];
    System.out.println(arr); 
    System.out.println(arr2); 
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VHKm4Ih2-1623631476615)(Java基础.assets/image-20201221212929213.png)]

两个变量指向一个数组

public static void main(String[] args) { 
    // 定义数组，存储3个元素 
    int[] arr = new int[3]; 
    //数组索引进行赋值 
    arr[0] = 5; 
    arr[1] = 6; 
    arr[2] = 7; 
    //输出3个索引上的元素值 
    System.out.println(arr[0]); 
    System.out.println(arr[1]); 
    System.out.println(arr[2]); 
    //定义数组变量arr2，将arr的地址赋值给arr2 
    int[] arr2 = arr; 
    arr2[1] = 9; 
    System.out.println(arr[1]);
}

在这里插入图片描述

第十二章数组的常见操作

12.1 数组越界异常

观察一下代码，运行后会出现什么结果。

public static void main(String[] args) {     int[] arr = {1,2,3};    System.out.println(arr[3]);}

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运

行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
在这里插入图片描述

12.2 数组空指针异常

观察一下代码，运行后会出现什么结果。

public static void main(String[] args) {
    int[] arr = {1,2,3}; 
    arr = null; 
    System.out.println(arr[0]);
}

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候

会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修

改我们编写的代码。

在这里插入图片描述

空指针异常在内存图中的表现

在这里插入图片描述

12.3 数组遍历

数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

public static void main(String[] args) { 
    int[] arr = { 1, 2, 3, 4, 5 }; 
    System.out.println(arr[0]); 
    System.out.println(arr[1]); 
    System.out.println(arr[2]); 
    System.out.println(arr[3]); 
    System.out.println(arr[4]); 
}

以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改

造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。

public static void main(String[] args) {
     int[] arr = { 1, 2, 3, 4, 5 };   
       for (int i = 0; i < arr.length; i++) {  
              System.out.println(arr[i]);  
                 }
     }

12.4 数组获取最大值元素

**最大值获取：**从数组的所有元素中找出最大值。
实现思路：
- 定义变量，保存数组0索引上的元素
- 遍历数组，获取出数组中的每个元素
- 将遍历到的元素和保存数组0索引上值的变量进行比较
- 如果数组元素的值大于了变量的值，变量记录住新的值
- 数组循环遍历结束，变量保存的就是数组中的最大值

public static void main(String[] args) { 
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 }; 
    //定义变量，保存数组中0索引的元素
    int max = arr[0]; 
    //遍历数组，取出每个元素 
    for (int i = 0; i < arr.length; i++) { 
        //遍历到的元素和变量max比较 
        //如果数组元素大于max 
        if (arr[i] > max) {
            //max记录住大值 max = arr[i];
        } 
    }
    System.out.println("数组最大值是： " + max); 
}

12.5 数组反转

数组的反转： 数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
**实现思想：**数组最远端的元素互换位置。
- 实现反转，就需要将数组最远端元素位置交换
- 定义两个变量，保存数组的最小索引和最大索引
- 两个索引上的元素交换位置
- 最小索引++，最大索引–，再次交换位置
- 最小索引超过了最大索引，数组反转操作结束

在这里插入图片描述

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*循环中定义变量min=0最小索引 max=arr.length‐1最大索引 min++,max‐‐ */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) { 
        //利用第三方变量完成数组中的元素交换 
        int temp = arr[min]; 
        arr[min] = arr[max];
        arr[max] = temp; 
    }
    // 反转后，遍历数组 for (int i = 0; i < arr.length; i++) { 
    System.out.println(arr[i]);
   } 
}

12.6 数组作为方法参数

以前的方法中我们学习了方法的参数和返回值，但是使用的都是基本数据类型。那么作为引用类型的数组能否作为

方法的参数进行传递呢，当然是可以的。

数组作为方法参数传递，传递的参数是数组内存的地址。

public static void main(String[] args) { 
    int[] arr = { 1, 3, 5, 7, 9 };
    //调用方法，传递数组 
    printArray(arr); 
}
    /* 创建方法，方法接收数组类型的参数 进行数组的遍历 */
public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) { 
        System.out.println(arr[i]); 
    } 
}

在这里插入图片描述

12.7 数组作为方法返回值

数组作为方法的返回值，返回的是数组的内存地址

public static void main(String[] args) { 
    //调用方法，接收数组的返回值 
    //接收到的是数组的内存地址 
    int[] arr = getArray();
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    } 
}
/*创建方法，返回值是数组类型 return返回数组的地址 */
public static int[] getArray() { 
    int[] arr = { 1, 3, 5, 7, 9 }; 
    //返回数组的地址，返回到调用者 return arr;
}

在这里插入图片描述

12.8 方法的参数类型区别

代码分析

分析下列程序代码，计算输出结果。
    public static void main(String[] args) { 
    int a = 1;
    int b = 2; 
    System.out.println(a); 
    System.out.println(b);
    change(a, b);
    System.out.println(a); 
    System.out.println(b);
}
public static void change(int a, int b) { 
    a = a + b; b = b + a; 
}

分析下列程序代码，计算输出结果。
public static void main(String[] args) { 
    int[] arr = {1,3,5};
    System.out.println(arr[0]);
    change(arr); 
    System.out.println(arr[0]);
}
public static void change(int[] arr) {
    arr[0] = 200;
}

总结:

方法的参数为基本类型时,传递的是数据值.方法的参数为引用类型时,传递的是地址值

校生兄

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础入门（一）

第一章开发前言1.1 Java语言概述什么是java语言？Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。所谓编程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。Java语言发展历史1995年Sun公司发布Java1.0版本1997年发布Java 1.1版本1998年发布Java 1.2版本2000年发布Java 1.3版本2002年发布Java 1.4版本2004年发布
复制链接

扫一扫