JAVA基础笔记
一：Java语言概述
1.软件开发介绍
- 软件开发软件，即一系列按照特定顺序组织的计算机数据和指令的集合。软件有系统软件和应用软件之分。
人机交互方式 - 图形化界面(Graphical User Interface GUI)这种方式简单直观，使用者易于接受，容易上手操作。
- 命令行方式(Command Line InterfaceCLI)：需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令。
Pascal之父Nicklaus Wirth：“Algorithms+DataStructures=Programs”
1.1常用的DOS命令
- win+R 一起按下 ，输入cmd ，可以打开dos界面
- dir : 列出当前目录下的的文件以及文件夹
- md ：创建目录
- rd ：删除目录
- cd ：进入指定目录
- cd… ：退回到上一级目录
- cd ：退回到上一目录
- del ：删除文件
- exit ：退出dos命令行
2.计算机编程语言介绍
-
什么是计算机语言？
-
语言：是人与人之间用于沟通的一种方式。
-
计算机语言：人与计算机交流的方式。
-
第一代语言：（机器语言）指令以二进制代码形式存在。
-
第二代语言：（汇编语言）使用助记符表示一条机器指令。
-
第三代语言：（高级语言）
- C、Pascal、Fortran面向过程的语言
- C++面向过程/面向对象
- Java跨平台的纯面向对象的语言
- .NET跨语言的平台
- Python、Scala…
- 面向过程：例如张三打篮球，他打篮球的全部过程(拿球、传球、投篮……)。
- 面向对象：人的对象，人的运动的动作，运动的器械这三个对象，实例化一个张三的对象，对象有一个打篮球的动作，器械是篮球。
- 面向对象能更好的在抽象的层面分析问题，在程序实现跨越极大的赋予之前的代码。这些是面向过程编程极难实现的。
3.Java语言概述
- 是SUN(Stanford University Network，斯坦福大学网络公司) 1995年推出的一门高级编程语言。
- 是一种面向Internet的编程语言。Java一开始富有吸引力是因为Java程序可以在Web浏览器中运行。这些Java程序被称为Java小程序（applet）。applet使用现代的图形用户界面与Web用户进行交互。applet内嵌在HTML代码中。
- 随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。后台开发：Java、PHP、Python、Go、Node.js
3.1Java简史
- 1991年Green项目，开发语言最初命名为Oak (橡树)
- 1994年，开发组意识到Oak 非常适合于互联网
- 1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作
- 1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最
- 1998年，发布JDK 1.2，同年发布企业平台J2EE
- 1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生
- 2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0
- 2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME
- 2009年，Oracle公司收购SUN，交易价格74亿美元
- 2011年，发布JDK 7.0
- 2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本
- 2017年，发布JDK 9.0，最大限度实现模块化
- 2018年3月，发布JDK 10.0，版本号也称为18.3
- 2018年9月，发布JDK 11.0，版本号也称为18.9
- 2019年3月20日，Java SE 12 发布。Java 12是短期支持版本。
- 2019年9月23日，Java SE 13发布，此版本中添加了“文本块”，文本块是一个多行字符串文字，避免对大多数转义序列的需要，以可预测的方式自动格式化字符串，并在需要时让开发人员控制格式。
3.2Java技术体系平台
1、JavaSE(Java Standard Edition)标准版
支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API，此版本以前称为J2SE
2、JavaEE(Java Enterprise Edition)企业版
是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如:Servlet 、Jsp等，主要针对于Web应用程序开发。版本以前称为J2EE
3、Java ME(Java Micro Edition)小型版
支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持，此版本以前称为J2ME
4、Java Card
支持一些Java小程序（Applets）运行在小内存设备（如智能卡）上的平台
5、从Java的应用领域来分，Java语言的应用方向主要表现在以下几个方面：
- 企业级应用：主要指复杂的大企业的软件系统、各种类型的网站。Java的安全机制以及它的跨平台的优势，使它在分布式系统领域开发中有广泛应用。应用领域包括金融、电信、交通、电子商务等。
- Android平台应用：Android应用程序使用Java语言编写。Android开发水平的高低很大程度上取决于Java语言核心能力是否扎实。
- 大数据平台开发：各类框架有Hadoop，spark，storm，flink等，就这类技术生态圈来讲，还有各种中间件如flume，kafka，sqoop等等，这些框架以及工具大多数是用Java编写而成，但提供诸如Java，scala，Python，R等各种语言API供编程。
- 移动领域应用：主要表现在消费和嵌入式领域，是指在各种小型设备上的应用，包括手机、PDA、机顶盒、汽车通信设备等。
Java主要特性
- Java语言是易学的。Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。
- Java语言是强制面向对象的。Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。
- Java语言是分布式的。Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
- Java语言是健壮的。Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。
- Java语言是安全的。Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。如：安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查。
- Java语言是体系结构中立的。Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。
- Java语言是解释型的。如前所述，Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统的解释器中运行。先编译后解释。
- Java是性能略高的。与那些解释型的高级脚本语言相比，Java的性能还是较优的。
- Java语言是原生支持多线程的。在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。
4.Java程序运行机制及运行过程
- 特点一：面向对象
- 两个基本概念：类、对象
- 三大特性：封装、继承、多态
- 特点二：健壮性
- 吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制
- 特点三：跨平台性
- 跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run Anywhere”
- 原理：只要在需要运行java 应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。
4.1Java两种核心机制
1、Java虚拟机(Java VirtalMachine)
- JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器。
- 对于不同的平台，有不同的虚拟机。
- 只有某平台提供了对应的java虚拟机，java程序才可在此平台运行。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
- Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”。[外链图片转存失败,源站可能有防盗在这里插入!链机制,建描述]议将图片上https://传(imblog-dnimg.cn/img_convert/UEET6e8896a45811378ed13d38b7df66.png#pic_center344)(#pic_center)]
2、垃圾收集机制(Garbage Collection)
- 不再使用的内存空间应回收——垃圾回收。
- 在C/C++等语言中，由程序员负责回收无用内存。
- Java 语言消除了程序员回收无用内存空间的责任：它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。
- 垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预。
Java程序还会出现内存泄漏和内存溢出问题吗？Yes!
5.Java语言的环境搭建
选择合适的文本编辑器或IDE 开发
- eclipse——https://www.eclipse.org/downloads/packages/
- IDEA——https://www.jetbrains.com/idea/download/
- 官网太慢，备用地址：链接：https://pan.baidu.com/s/1rnBuCPKCyunCTyNKoRY7YA，提取码：4x3d
- 安装步骤：https://www.yuque.com/nizhegechouloudetuboshu/library/rc1889。
6.开发体验–Hello World
1、步骤：
- 将Java 代码编写到扩展名为.java 的文件中。
- 选择最简单的编辑器：记事本。
- 敲入代码class Test{}将文件保存成Test.java，这个文件是存放java代码的文件，称为源文件。
2、第一个Java程序
public class Test {
public static void main(String[] args) {
System.out.println("hello world");
}
}
123456789
1、通过javac命令对该java 文件进行编译。
- 有了java源文件，通过编译器将其编译成JVM可以识别的字节码文件。
- 在该源文件目录下，通过javac编译工具对Test.java文件进行编译。
- 如果程序没有错误，没有任何提示，但在当前目录下会出现一个Test.class文件，该文件称为字节码文件，也是可以执行的java的程序。
2、通过java 命令对生成的class 文件进行运行。
- 有了可执行的java程序(Test.class字节码文件)
- 通过运行工具java.exe对字节码文件进行执行。
- 出现提示：缺少一个名称为main的方法。
- 因为一个程序的执行需要一个起始点或者入口，所以在Test类中的加入public static void main(String[] args){}
- 对修改后的Test.java源文件需要重新编译，生成新的class文件后，再进行执行。
- 发现没有编译失败，但也没有任何效果，因为并没有告诉JVM要帮我们做什么事情，也就是没有可以具体执行的语句。
- 想要和JVM来个互动，只要在main方法中加入一句System.out.println(“Hello World");因为程序进行改动，所以再重新编译，运行即可。
7.常见问题及解决办法
1、问题1
- 源文件名不存在或者写错
- 当前路径错误
- 后缀名隐藏问题
2、问题2
- 类文件名写错，尤其文件名与类名不一致时，要小心
- 类文件不在当前路径下，或者不在classpath指定路径下
3、问题3
- 声明为public的类应与文件名一致，否知编译失败
4、问题4
- 编译失败，注意错误出现的行数，再到源代码中指定位置改错
总结：学习编程最容易犯的错是语法错误。Java要求你必须按照语法规则编写代码。如果你的程序违反了语法规则，例如：忘记了分号、大括号、引号，或者拼错了单词，java编译器都会报语法错误。尝试着去看懂编译器会报告的错误信息。
8.注释（comment）
-
用于注解说明解释程序的文字就是注释。
-
Java中的注释类型：
-
单行注释
- 格式：//注释文字
-
多行注释
- 格式：/* 注释文字*/
- 注：对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
多行注释里面不允许有多行注释嵌
-
文档注释(java特有)
-
格式：
/** * @author 指定java程序的作者** * @version 指定源文件的版本** */ 1234注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
-
-
-
提高了代码的阅读性；调试程序的重要方法。
-
注释是一个程序员必须要具有的良好编程习惯。
-
将自己的思想通过注释先整理出来，再用代码去体现。
9.小结—第一个程序
- Java源文件以“java”为扩展名。源文件的基本组成部分是类（class），如本例中的HelloWorld类。
- Java应用程序的执行入口是main()方法。它有固定的书写格式：
public static void main(String[] args) {…} - Java语言严格区分大小写。
- Java方法由一条条语句构成，每个语句以“;”结束。
- 大括号都是成对出现的，缺一不可。
- 一个源文件中最多只能有一个public类。其它类的个数不限，如果源文件包含一个public类，则文件名必须按该类名命名。
二：变量、标识符、保留字、变量
1.关键字与保留字
1、关键字(keyword)的定义和特点
- 定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
- 特点：关键字中所有字母都为小写
- 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
2、保留字(reserved word)
Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字goto、const。
2.标识符
2.1什么是标识符（Identifier）
- Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧：凡是自己可以起名字的地方都叫标识符。
2.2定义合法标识符规则【重要】
- 由 26 个英文字母大小写，0-9，_或$ 组成
- 数字不可以开头。
- 标识符不能包含空格。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java 中严格区分大小写，长度无限制。
2.3Java中的名称命名规范
1、Java 中的名称命名规范：
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，**所有单词的首字母大写：**XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
2、注意点
- 注意 1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
- 注意 2：java 采用 unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用。
- 更多细节详见《代码整洁之道》
3.变量
3.1变量的声明与使用
1、变量的概念：
- 内存中的一个存储区域；
- 该区域的数据可以在同一类型范围内不断变化；
- 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值。
2、变量的作用：
- 用于在内存中保存数据。
3、使用变量注意：
- Java 中每个变量必须先声明，后使用；
- 使用变量名来访问这块区域的数据；
- 变量的作用域：其定义所在的一对{ }内；
- 变量只有在其作用域内才有效；
- 同一个作用域内，不能定义重名的变量；
4、声明变量
- 语法：<数据类型> <变量名称>
- 例如：int var;
5、变量的赋值
- 语法：<变量名称> = <值>
- 例如：var = 10;
6、声明和赋值变量
- 语法：<数据类型><变量名>= <初始化值>
- 例如：int var = 10
7、补充：变量的分类-按声明的位置的不同
- 在方法体外，类体内声明的变量称为成员变量。
- 在方法体内部声明的变量称为局部变量。
8、注意：二者在初始化值方面的异同:
- 同：都有生命周期
- 异：局部变量除形参外，需显式初始化。
3.2基本数据类型
1、变量的分类-按数据类型
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。
3.2.1整数类型：byte、short、int、long
- Java 各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 java 程序的可移植性。
- java 的整型常量默认为 int 型，声明 long 型常量须后加‘l’或‘L’
- java 程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| byte | 1字节=8bit位 | -128 ~ 127 |
| short | 2字节 | -2^15~ 2^15-1 |
| int | 4字节 | -2^31~ 2^31-1 (约21亿) |
| long | 8字节 | -2^63~ 2^63-1 |
- 1MB = 1024KB 1KB= 1024B B= byte ? bit?
- bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。
/*
Java定义的数据类型
一、变量按照数据类型来分：
基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
引用数据类型：
类：class
接口：interface
数组：array
二、变量在类中声明的位置：
成员变量 vs 局部变量
*/
class VariableTest1{
public static void main(String[] args) {
//1. 整型：byte(1字节=8bit) short(2字节） \ int (4字节）\ long(8字节)
//① byte范围：-128 ~ 127
byte b1 = 12;
byte b2 = -128;
// b2 = 128; //编译不通过
System.out.println(b1);
System.out.println(b2);
// ② 声明long型变量，必须以“1”或“L”结尾
short s1 = 128;
int i1 = 12345;
long l1 = 345678586;
System.out.println(l1);
}
}
3.2.2浮点类型：float、double
- 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
- 浮点型常量有两种表示形式：
- 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
- 科学计数法形式:如：5.12e2 512E2 100E-2
- float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
- double:双精度，精度是float的两倍。通常采用此类型。
- Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| 单精度float | 4字节 | -3.403E38 ~ 3.403E38 |
| 双精度double | 8字节 | -1.798E308 ~ 1.798E308 |
3.2.3字符类型：char
- char 型数据用来表示通常意义上“字符”(2字节)
- Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
- 字符型变量的三种表现形式：
- 字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
- Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; //’\n’表示换行符
- 直接使用Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示\n。
- char类型是可以进行运算的。因为它都对应有Unicode码。
/*
Java定义的数据类型
一、变量按照数据类型来分：
基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
引用数据类型：
类：class
接口：interface
数组：array
二、变量在类中声明的位置：
成员变量 vs 局部变量
*/
class VariableTest1{
public static void main(String[] args) {
//2. 浮点型：float(4字节) \ double(8字节)
//① 浮点型，表示带小数点的数值
//② float表示数值的范围比long还大
double d1 = 12.3;
System.out.println(d1 +1);
//定义float类型变量时，变量要以"f" 或"F"结尾
float f1 = 12.3F;
System.out.println(f1);
//② 通常，定义浮点型变量时，使用double变量
//3. 字符型：char(1字符=2字节)
//① 定义char型变量，通常使用一对''
char c1 = 'a';
//编译不通过
//c1 = 'AB';
System.out.println(c1);
char c2 = '1';
char c3 = '中';
char c4 = '&';
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
//② 表示方式：1.声明一个字符；2.转义字符；3.直接使用Unicode值来表示字符型常量
char c5 = '\n'; //换行符
c5 = '\t'; //制表符
System.out.print("hello" + c5);
System.out.println("world");
char c6 = '\u0123';
System.out.println(c6);
char c7 = '\u0043';
System.out.println(c7);
}
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
了解：ASCII 码
- 在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有0 和1 两种状态，因此8个二进制位就可以组合出256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示256 种不同的状态，每一个状态对应一个符号，就是256 个符号，从0000000 到11111111。
- ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
- 缺点：
- 不能表示所有字符。
- 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel(ג)。
了解：Unicode 编码
- 乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
- Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用Unicode 没有乱码的问题。
- Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别Unicode 和ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大的浪费。
了解：UTF-8
- UTF-8 是在互联网上使用最广的一种Unicode 的实现方式。
- UTF-8 是一种变长的编码方式。它可以使用1-6 个字节表示一个符号，根据不同的符号而变化字节长度。
- UTF-8的编码规则：
- 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
- 对于多字节的UTF-8编码，如果编码包含n 个字节，那么第一个字节的前n位为1，第一个字节的第n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。
3.2.4布尔类型：boolean
- boolean 类型用来判断逻辑条件，一般用于程序流程控制：
- if条件控制语句；
- while循环控制语句；
- do-while循环控制语句；
- for循环控制语句；
- boolean类型数据只允许取值true和false，无null。
- 不可以使用0或非0 的整数替代false和true，这点和C语言不同。
- Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。———《java虚拟机规范8版》
class VariableTest1{
public static void main(String[] args) {
//4. 布尔型：boolean
//① 只能取两个值之一：true 、false
//② 常常在条件判断、循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if(isMarried){
System.out.println("禁止入内！");
}else{
System.out.println("可以参观！");
}
}
}
3.3基本数据类型转换
- 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
- 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
- byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
- boolean类型不能与其它数据类型运算。
- 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。
/*
基本数据类型之间的运算规则：
前提：这里讨论只是7中基本数据类型变量的运算。不包含boolean类型的。
1. 自动类型提升：
当容量小的数据类型的变量和容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
char、byte、short-->int-->long-->float-->double
特别的：当byte、char、short三种类型的变量做运算时，结果为int类型
2. 强制类型转换：
说明：此时容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
class VariableTest2{
public static void main(String[] args) {
byte b1 = 2;
int i1 = 129;
//编译不通过
// byte b2 = b1 + i1;
int i2 = b1 + i1;
long l1 = b1 + i1;
System.out.println(i2);
System.out.println(l1);
float f = b1 + i1;
System.out.println(f);
//***************特别的**************************
char c1 = 'a'; //97
int i3 = 10;
int i4 = c1 + i3;
System.out.println(i4);
short s2 = 10;
//编译错误
// char c3 = c1 + s2;
byte b2 = 10;
// char c3 = c1 + b2; //编译不通过
// short s3 = b2 + s2; //编译不通过
// short s4 = b1 + b2; //编译不通过
}
}
class VariableTest4{
public static void main(String[] args){
//1. 编码情况
long l = 123456;
System.out.println(l);
//编译失败：过大的整数
//long l1 = 452367894586235;
long l1 = 452367894586235L;
//**************************
//编译失败
// float f1 = 12.3;
//2. 编码情况2:
//整型变量，默认类型为int型
//浮点型变量，默认类型为double型
byte b = 12;
// byte b1 = b + 1; //编译失败
// float f1 = b + 12.3; //编译失败
}
}
3.4字符串类型：String
- String不是基本数据类型，属于引用数据类型
- 使用方式与基本数据类型一致。例如：String str= “abcd”;
- 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
/*
String类型变量的使用
1. String属于引用数据类型
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算；+
4. 运算的结果任然是String类型
*/
class StringTest{
public static void main(String[] args){
String s1 = "Good Moon!";
System.out.println(s1);
String s2 = "a";
String s3 = "";
// char c = ''; //编译不通过
//*******************************
int number = 1001;
String numberStr = "学号:";
String info = numberStr + number; //连接运算
boolean b1 = true;
String info1 = info + true;
System.out.println(info1);
}
}
1234567891011121314151617181920212223242526272829
练习1
String str1 = 4; //判断对错：no
String str2 = 3.5f + “”; //判断str2对错：yes
System.out.println(str2); //输出：”3.5”
System.out.println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1
3.5强制类型转换
- 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
- 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
- 如：
String a = “43”; inti= Integer.parseInt(a); boolean类型不可以转换为其它的数据类型。
练习2
判断是否能通过编译
short s = 5;
s = s-2; //判断：no
byte b = 3;
b = b + 4;//判断：no
b = (byte)(b+4);//判断：yes
char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：yes
byte b = 5;
short s = 3;
short t = s + b;//判断：no
4.进制
4.1进制与进制间的转换
关于进制
- 所有数字在计算机底层都以二进制形式存在。
- 对于整数，有四种表示方式：
- 二进制(binary)：0,1 ，满2进1.以
0b或0B开头。 - 十进制(decimal)：0-9 ，满10进1。
- 八进制(octal)：0-7 ，满8进1. 以数字
0开头表示。 - 十六进制(hex)：0-9及A-F，满16进1. 以
0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0
- 二进制(binary)：0,1 ，满2进1.以
class BinaryTest{
public static void main(String[] args){
int num1 = 0b110;
int num2 = 110;
int num3 = 0127;
int num4 = 0x110A;
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
System.out.println("num3 = " + num3);
System.out.println("num4 = " + num4);
}
}
4.2二进制
- Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位
- 二进制的整数有如下三种形式：
- 原码：直接将一个数值换成二进制数。最高位是符号位
- 负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
- 负数的补码：其反码加1。计算机以二进制补码的形式保存所有的整数。
- 正数的原码、反码、补码都相同，负数的补码是其反码+1
为什么要使用原码、反码、补码表示形式呢？
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
二进制——》十进制
原码与反码是帮助推导出补码而存在的！！！
十进制——》二进制
- 对于正数来讲：原码、反码、补码是相同的：三码合一。
- 计算机底层都是使用二进制表示的数值。
- 计算机底层都是使用的数值的
补码保存数据的。
4.3进制间转化
十进制二进制互转
- 二进制转成十进制乘以2的幂数
- 十进制转成二进制除以2取余数
三：运算符
1.运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
- 算术运算符
- 赋值运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- 位运算符
- 三元运算符
1.1算术运算符
/*
运算符之一：算术运算符
+ - * / % (前)++ (后)++ (前)-- (后)--
*/
class Day3Test{
public static void main(String[] args) {
//除号：/
int num1 = 12;
int num2 = 5;
int resule1 = num1 / num2;
System.out.println(resule1); //2
int result2 = num1 / num2 * num2;
System.out.println(result2);
double result3 = num1 / num2;
System.out.println(result3); //2.0
double result4 = num1 / num2 + 0.0; //2.0
double result5 = num1 / (num2 + 0.0); //2.4
double result6 = (double)num1 / num2; //2.4
double result7 = (double)(num1 / num2); //2.0
System.out.println(result5);
System.out.println(result6);
// %：取余运算
//结果的符号与被模数的符号相同
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);
//(前)++ : 先自增1，后运算
//(后)++ ：先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);
int a3 = 10;
a3++; //a3++;
int b3 = a3;
//注意点：
short s1 = 10;
//s1 = s1 + 1; //编译失败
// s1 = (short)(s1 + 1); //正确的
s1++; //自增1不会改变本身变量的数据类型
System.out.println(s1);
//问题：
byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);
//(前)-- :先自减1，后运算
//(后)-- ：先运算，后自减1
int a4 = 10;
int b4 = a4--; //int b4 = --a4;
System.out.println("a4 = " + a4 + ",b4 = " + b4);
}
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879
算术运算符的注意问题
- 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
- 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：intx=3510;x=x/1000*1000; x的结果是？
- “+”除字符串相加功能外，还能把非字符串转换成字符串.例如：System.out.println(“5+5=”+5+5); //打印结果是？5+5=55 ?
/*
练习：随意给出一个三位数的整数，打印显是它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
*/
class AriExer{
public static void main(String[] args){
int num = 187;
System.out.println("百位数：" + num/100);
System.out.println("十位数：" + num%100/10);
System.out.println("个位数：" + num%10);
}
}
1.2赋值运算符
-
符号：
=- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。
-
扩展赋值运算符：
+=, -=, *=, /=, %=
/*
运算符之二：赋值运算符
+= -= *= /=
*/
class SetValueTest{
public static void main(String[] args) {
//赋值符号：=
int i1 = 10;
int j1 = 10;
int i2,j2;
//连续赋值
i2 = j2 = 10;
int i3 = 10,j3 = 20;
//***********************
int num1 = 10;
num1 += 2; //num1 = num1 + 2;
System.out.println(num1); //12
int num2 = 12;
num2 %= 5; //num2 = num2 % 5;
System.out.println(num2);
short s1 = 10;
//s1 = s1 + 2; //编译失败
s1 += 2; //结论：不会改变变量本身的数据类型
System.out.println(s1);
//开发中，如果希望变量实现+2的操作，有几种方法？？？(int num = 10)
//方式一：num = num + 2;
//方式二：num += 2;(推荐)
//开发中，如果希望变量实现+1的操作，有几种方法？？？(int num = 10)
//方式一：num = num + 1;
//方式二：num += 1;
//方式三：num++;(推荐)
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142
class MkFan{
public static void main(String[] args) {
//练习1：
int i = 1;
i *= 0.1;
System.out.println(i);//
i++;
System.out.println(i);//
//练习2：
int m = 2;
int n1 = 3;
n1 *= m++;
System.out.println("m=" + m); //3
System.out.println("n1=" + n1); //6
//练习3：
int n = 10;
n += (n++) + (++n);
System.out.println(n); //32
}
}
1.3比较运算符
- 比较运算符的结果都是
boolean型，也就是要么是true，要么是false。 - 比较运算符“
==”不能误写成“=” 。
/*
运算符之三：比较运算符
== != > < >= <= instanceof
结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 =
*/
class CompareTest{
public static void main(String[] args){
int i = 10;
int j = 20;
System.out.println(i==j); //false
System.out.println(i = j); //20
boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1); //false
System.out.println(b2 = b1); //true
}
}
1.4逻辑运算符
&—逻辑与|—逻辑或！—逻辑非&&—短路与||—短路或^—逻辑异或
-
逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
-
“
&”和“
&&”的区别：
- 单
&时，左边无论真假，右边都进行运算； - 双
&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
- 单
-
“
|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。 -
异或(
^)与或(|)的不同之处是：当左右都为true时，结果为false。理解：异或，追求的是“异”!
练习
/*
运算符之四：逻辑运算符
& && | || ！ ^
说明：
1. 逻辑与运算符操作的都是boolean类型的变量
*/
class LogicTest{
public static void main(String[] args){
//区分& 与 &&
//相同点1：& 与 && 的运算结果都相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，&继续执行符号
//开发中，推荐使用&&
boolean b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("我现在在南京");
}else{
System.out.println("我现在在北京");
}
System.out.println("num1 = " + num1);
boolean b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("我现在在南京");
}else{
System.out.println("我现在在北京");
}
System.out.println("num2 = " + num2);
//区分：| 与 ||
//相同点1：| 与 || 的运算结果都相同
//相同点2：当符号左边是false时，二者都会执行符号右边的运算
//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
//开发中，推荐使用||
boolean b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
System.out.println("我现在在南京");
}else{
System.out.println("我现在在北京");
}
System.out.println("num3 = " + num3);
boolean b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
System.out.println("我现在在南京");
}else{
System.out.println("我现在在北京");
}
System.out.println("num4 = " + num4);
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
class LogoinTest{
public static void main(String[] args){
boolean x = true;
boolean y = false;
short z = 42;
//if(y == true)
if((z++==42)&&(y=true))z++;
if((x=false)||(++z==45)) z++;
System.out.println("z=" + z); //46
}
}
1.5位运算符
1、位运算是直接对整数的二进制进行的运算
2、注意：无<<<
/*
运算符之五：位运算符(了解)
结论：
1.位运算符操作的都是整型的数据变量
2.<< : 在一定范围内，每向左移一位，相当于 * 2
>> : 在一定范围内，每向右移一位，相当于 / 2
面试题：最高效的计算2 * 8 ？ 2 << 3 或 8 << 1
*/
class BitTest{
public static void main(String[] args){
int i = 21;
// i = -21;
System.out.println("i << 2 :" + (i << 2));
System.out.println("i << 3 :" + (i << 3));
System.out.println("i << 20 :" + (i << 20));
System.out.println("i << 27 :" + (i << 27));
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));
System.out.println("m & n :" + (m | n));
System.out.println("m & n :" + (m ^ n));
//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
//方式一：
// int tent = num1;
// num1 = num2;
// num2 = tent;
//方式二：
//好处：不用定义临时变量
//弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
// num1 = num1 + num2;
// num2 = num1 - num2;
// num1 = num1 - num2;
//方式三：使用位运算
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647
class BitTest{
public static void main(String[] args){
//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
//方式一：
// int tent = num1;
// num1 = num2;
// num2 = tent;
//方式二：
//好处：不用定义临时变量
//弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
// num1 = num1 + num2;
// num2 = num1 - num2;
// num1 = num1 - num2;
//方式三：使用位运算
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
}
}
1.6三元运算符
/*
运算符之六：三元运算符
1.结构：(条件表达式)？表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true,则执行表达式1
如果表达式为false,则执行表达式2
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符是可以嵌套的
3. 凡是可以使用三元运算的地方，都是可以改写if-else。
反之，则不一定成立！！！
*/
class SanTest{
public static void main(String[] args) {
//获取两个整数的最大值
int m = 12;
int n = 5;
int max = (m > n)? m : n;
System.out.println(max);
double num = (m > n) ? 2 : 1.0;
//(m > n) ? 2 : "n大"; //编译错误
//****************************************
String str = (m > n) ? "m大" : ((m == n)? "m和n相等" : "n大");
System.out.println(str);
//****************************************
//获取三个数中的最大值
int n1 = 12;
int n2 = 30;
int n3 = -43;
int max1 = (n1 > n2) ? n1 : n2;
int max2 = (max1 > n3) ? max1 : n3;
System.out.println("三个数中的最大值是：" + max2);
//此方法：pass
int max3 = (((n1 > n2)? n1 : n2) > n3) ?((n1 > n2) ? n1 : n2) : n3;
System.out.println("三个数中的最大值是：" + max3);
//改写成if-else
if(m > n){
System.out.println(m);
}else{
System.out.println(n);
}
}
}
2.运算符的优先级
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
- 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。
1460
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
