【无标题】

最新推荐文章于 2022-06-13 20:26:10 发布

面向世界编程

最新推荐文章于 2022-06-13 20:26:10 发布

阅读量679

点赞数

分类专栏： java 文章标签： java 后端

本文链接：https://blog.csdn.net/Zhang122593332/article/details/124102221

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、java特点

1、java语言是面向对象的（oop）

2、java语言是健壮性的，Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证

3、 Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台]

4、 Java 语言是解释型的
解释性语言：javascript,PHP, java 编译性语言: c / c++
区别是：解释性语言，编译后的代码，不能直接被机器执行,需要解释器来执行, 编译性语言, 编译后的代码, 可以直接被机器执行, c /c++

JDK 基本介绍

JDK 的全称(Java Development Kit Java 开发工具包)
JDK = JRE + java 的开发工具 [java, javac,javadoc,javap 等]

JVM 是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器，包含在JDK 中.

JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE 了。

JRE 基本介绍

JRE(Java Runtime Environment Java 运行环境)
JRE = JVM + Java 的核心类库[类]
包括 Java 虚拟机(JVM Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。

JDK、JRE 和 JVM 的包含关系

JDK = JRE + 开发工具集（例如 Javac,java 编译工具等)
JRE = JVM + Java SE 标准类库（java 核心类库）
如果只想运行开发好的 .class 文件只需要 JRE

Java基本代码格式

Java源文件以 java为扩展名。源文件的基本组成部分是类(class)
Java应用程序的执行入口是main(方法。它有固定的书写格式:
public static void main(String[ args) {…}
Java语言严格区分大小写.
Java方法由一条条语句构成，每个语句以“；" 结束。
5.大括号都是成对出现的，缺一不可。 [习惯，先写{}再写代码]
6.一个源文件中最多只能有一个public类。其它类的个数不限。
7.如果源文件包含一个public类，则文件名必须按该类名命名!
8.一个源文件中最多只能有一个public类。其它类的个数不限，也可以将main方法写在非public类中，然后指定运行非public 类，这样入口方法就是非public的main方法

Java 转义字符

Java 常用的转义字符

在控制台，输入 tab 键，可以实现命令补全

"\“代表转义符

\t ：一个制表位，实现对齐的功能
\n ：换行符
\ \：表示一个\

\ " :一个"
\ ‘：一个’
\r :一个回车

注释(comment)

用于注解说明解释程序的文字就是注释，注释提高了代码的阅读性（可读性）；注释是一个程序员必须要具有的良
好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。 [举例]

单行注释 //
多行注释 /* */
文档注释 /** */

常用的 dos 命令

1) 查看当前目录是有什么内容 dir
   dir dir d:\abc2\test200
2) 切换到其他盘下：盘符号 cd : change directory
   案例演示：切换到 c 盘 cd /D c:
3) 切换到当前盘的其他目录下 (使用相对路径和绝对路径演示), ..\表示上一级目录
   案例演示： cd d:\abc2\test200 cd ..\..\abc2\test200
4) 切换到上一级：
   案例演示： cd ..
5) 切换到根目录：cd \
   案例演示：cd \
6) 查看指定的目录下所有的子级目录 tree
7) 清屏 cls [苍老师]
8) 退出 DOS exit
9) 说明: (md[创建目录],rd[删除目录],copy[拷贝文件],del[删除文件],echo[输入内容到文件],type,move[剪切]) => Linux,

二、变量

概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。

变量使用的基本步骤

变量必须先声明在使用

声明变量
int a;
赋值
a = 60; // 把 60 赋给 a
使用 System.out.println(a);
//也可以一步到位[int a = 60; 通常我们是一步完成]

变量使用注意事项

1.变量表示内存中的一个存储区域[不同的变量，类型不同，占用的空间大小不同，
比如: int 4个字节，double 就是8个字节]
2.该区域有自己的名称[安量名]和类型[数据类型]
3.变量必须先声明，后使用，即有顺序
4.该区域的数据/值可以在同一类型范围内不断变化
5.变量在同一个作用域内不能重名
6.变量=变量名+值+数据类型。变量三要素

三、数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。

基本数据类型

整数型：

基本数据类型：

byte[1], 范围 （-128 ~ 127）
short[2], 范围 -2^15 ~ 2^15-1 （-32768-32767）
int[4], 范围 -2^31 ~ 2^31-1  (-2147483648-2147483647)
long[8], 范围 -2^63 ~ 2^63-1

## 引用数据类型：
类：closs
接口：interface
数组：[...]

浮点型：

   float[4],double[8]

关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位
尾数部分可能丢失，造成精度损失(小数都是近似值)。
通常情况下使用double类型及缴纳更多更高
1.与整数类型类似，Java 浮点类型也有固定的范围和字段长度，不受具体OS的
影响。[float 4个字节double是8个字节]
2. Java 的浮点型常量(具体值)默认为double型，声明float型常量，须后加’f’
或’F’
3.浮点型常量有两种表示形式
十进制数形式:如: 5.12 512.0f .512 (必须有小数点)
科学计数法形式:如: 5.12e2 [5.12*10的2次方] 5.12E-2 [5.12/10的2次方]
4.通常情况下，应该使用double型，因为它比float型更精确。[举例说明]

   double num9 = 2.1234567851;
   float num10 = 2.1234567851F;

5.浮点数使用陷阱:2.7和8.1 / 3比较

   double num7 = 2.7;
   double num8=8.1/ 3;
   if Math.abs(num7 - num8) < .00001)[
   System out. orintln("相等”):

字符型:

 char[2]

字符类型可以表示单个字符,字符类型是 char，char 是两个字节(可以存放汉字)，多个字符我们用字符串 Stringan[1]

//在 java 中，char 的本质是一个整数，在默认输出时，是 unicode 码对应的字符
//要输出对应的数字，可以(int)字符
//char 类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码.

1.字符常量是用单引号(”)括起来的单个字符。
例如:

charc1 = 'a'; charc2 = '中'; charc3 = '9';

Java中还允许使用转义字符T来将其后的字符转变为特殊字符型常量。
例如:
charc3 = In’ ; // "\n’表示换行符
3.在java中， char的本质是个整数，在输出时，是unicode码对应的字符。
http://tool.chinaz.com/ Tools/Unicode.aspx
4.可以直接给char一个整数，然后输出时，会按照对应的unicode字符输出[97-》a]
char类型是可以进行运算的，相当于一个整数，因为它
都对应有Unicode码.

布尔类型：

boolean[1]

1.布尔类型也叫boolean类型，booolean类型数据只允许取值true和false,无
null

boolean类型占1个字节。
boolean 类型适于逻辑运算，一般用于程序流程控制:
1 if条件控制语句;
V while循环控制语句;
V do-while循环控制语句;
V for循环控制语句

基本数据类型转换

自动类型转换：

V介绍
当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，
这个就是自动类型转换
1数据类型按精度(容量)大小排序为

char --> int --> long--> float--> double 

byte--> short--> int--> long--> float--> double

自动类型转换注意和细节:

1.有多种类型的混合数据运算时，系统首先自动将所有数据转换成最大容量的那种数据类型，然后进行计算。

2.当把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换。

3.（byte，short）和char之间不会相互自动转换

4.byte，short,char 他们三者可以计算，在计算时首先转换为int类型。
5.boolean 不参与转换
6.自动提升原则：表达式结果的类型自动提升为操作数中最大的类型

强制类型转换：

介绍
自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符 ( )，但可能造成精度降低或溢出,格外要注意

int i= (int)1.9;
System.out.println(i);

int j=100;
byte b=(byte)j;
System.out.println(b);

强制类型转换细节:

1.当进行数据的大小从大> 小，就需要使用到强制转换
2.强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

//intx = (int)10*3.5+6*1.5;
inty = (int)(10*3.5+6*1.5);
System.out.println(y);

char类型可以保存int的常量值，但不能保存int的变量值，需要强转

   charc1 = 100; //ok
   int m = 100; //ok
   char c2 = m; //错误
   char c3=(char)m //ok
   System.out. rintnt(3//100对应的字符

byte和short, char类型在进行运算时，当做int类型处理。

基本数据类型转String

在程序开发中，我们经常需要将基本数据类型转成String类型。或者将String类
型转成基本数据类型。

1、基本数据类型转换为String类型

语法：将基本数据类型+” “即可
2、String类型转换为基本数据类型
使用基本数据类型对应的包装类，的相应方法，得到基本数据类型
语法：通过剧本类型的包装类调用parsexxx方法即可.

怎么把字符串转成字符 char -> 指含义是指把字符串的第一个字符得到
s5.charAt(0) 得到 s5 字符串的第一个字符 ‘1’

注意事项:

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

四、运算符

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

算术运算符

算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。

细节说明:

1.对于除号"/",它的整数除和小数除是有区别的:整数之间做除法时，只保留整
数部分而舍弃小数部分。例如: intx= 10/3 ,结果是3
2.当对一个数取模时，可以等价a%b=a-a/b*b，这样我们可以看到取模的-一
个本质运算。
3.当自增当做一个独立语言使用时，不管是++i;还是i++;都是一样的，等价
4.当自增当做一个表达式使用时j = ++i等价[?]
5.当自增当做一个表达式使用时j = i++等价[2]

// % 取模 ,取余
// 在 % 的本质看一个公式!!! a % b = a - a / b * b
// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
// 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
// -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1

前++：++i 先自增后赋值
后++：i++先赋值后自增
面试题1
int i= 1;//i-> 1
i=i+ +; //规则使用临时变量: (1) temp=i;(2) i=i+ 1:(3)i=temp:
System.out.println(); // 1
问:结果是多少?为什么?

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

练习：

假如还有 59 天放假，问：合 xx 个星期零 xx 天
定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。
[234.5]//编写一个 main 方法
public static void main(String[] args) {
//1.需求:
//假如还有 59 天放假，问：合 xx 个星期零 xx 天
//2.思路分析
//(1) 使用 int 变量 days 保存天数
//(2) 一个星期是 7 天星期数 weeks： days / 7 零 xx 天 leftDays days % 7
//(3) 输出
//3.代码

int days = 25911;
int weeks = days / 7;
int leftDays = days % 7;
System.out.println(days + "天 合" + weeks + "星期零"
+ leftDays + "天");
  //1.需求
  //定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为
  //：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
  //
  //2 思路分析
  //(1) 先定义一个 double huaShi 变量保存 华氏温度
  //(2) 根据给出的公式，进行计算即可 5/9*(华氏温度-100)
  // 考虑数学公式和 java 语言的特性
  //(3) 将得到的结果保存到 double sheShi
  //3 代码
  double huaShi = 1234.6;
  double sheShi = 5.0 / 9 * (huaShi - 100);
  System.out.println("华氏温度" + huaShi
+ " 对应的摄氏温度=" + sheShi);
  }

赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。

赋值运算符的分类
基本赋值运算符 = int a = 10;
复合赋值运算符
+= ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理
a += b; [等价 a = a + b; ]
a -= b; [等价 a = a - b; ]

assign ：分配，指派，賦值

赋值运算符特点

1) 运算顺序从右往左 int num = a + b + c;
2) 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值
   int num = 20; int num2= 78 * 34 - 10; int num3 = a;
3) 复合赋值运算符等价于下面的效果
   比如：a+=3;等价于 a=a+3; 其他类推
4) 复合赋值运算符会进行类型转换。
   byte b = 2; b+=3; b++;

关系运算符

[比较运算符]

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

细节说明

关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
关系运算符组成的表达式，我们称为关系表达式。 a > b
比较运算符"==“不能误写成”="

逻辑运算符

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

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

说明逻辑运算规则：

a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false
a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false
a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
!a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true
a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

&& 和 & 基本规则

名称语法特点
短路与&& 条件 1&&条件 2 两个条件都为 true，结果为 true,否则 false
逻辑与& 条件 1&条件 2 两个条件都为 true，结果为 true,否则 false

&& 和 & 使用区别

&&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
& 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低
开发中，我们使用的基本是使用短路与&&, 效率高

|| 和 | 基本规则

名称语法特点
短路或|| 条件 1||条件 2 两个条件中只要有一个成立，结果为 true,否则为 false
|逻辑或条件 1|条件 2 只要有一个条件成立，结果为 true,否则为 false

|| 和 | 使用区别

||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
开发中，我们基本使用 ||

取反基本规则

名称语法特点
! 非（取反） !条件如果条件本身成立，结果为 false，否则为 true

//!和^案例演示
public class InverseOperator {
//编写一个 main 方法
public static void main(String[] args) {
//! 操作是取反 T->F , F -> T
System.out.println(60 > 20); //T
System.out.println(!(60 > 20)); //F
//a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false
boolean b = (10 > 1) ^ ( 3 > 5);
System.out.println("b=" + b);//T
}
}

三元运算符

基本语法

条件表达式 ? 表达式 1: 表达式 2;
运算规则：

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

使用细节

表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)

三元运算符可以转成 if–else 语句

int res = a > b ? a++ : --b;
if ( a > b) res = a++;
else res = --b;

//三元运算符细节

public static void main(String[] args) {
//表达式 1 和表达式 2 要为可以赋给接收变量的类型
//(或可以自动转换/或者强制转换)
int a = 3;
int b = 8;
int c = a > b ? (int)1.1 : (int)3.4;//可以的
double d = a > b ? a : b + 3;//可以的，满足 int -> double
}

标识符的命名

规则和规范

标识符概念：

Java对各种变量、方法和类等命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符int num1 = 90;
, 标识符的命名规则(必须遵守)
.由26个英文字母大小写，0-9，或$组成
数字不可以开头。 int 3ab = 1;//错误
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。int totalNum = 10; intn = 90;
5.
标识符不能包含空格。intab = 90;

标识符命名规范[更加专业]

包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]
比如： TankShotGame
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小驼峰，简称驼峰法]
比如： tankShotGame
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
比如：定义一个所得税率 TAX_RATE

关键字

关键字的定义和特点 ( 不用背)
定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X6rlt3vj-1649665711397)(images\关键字.jpg)]

保留字

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

键盘输入语句

介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

Input.java , 需要一个 扫描器(对象), 就是Scanner
     mport java.util.Scanner;//表示把 java.util 下的 Scanner 类导入
//2. 创建 Scanner 对象 , new 创建一个对象,体会
// myScanner 就是 Scanner 类的对象
   Scanner myScanner = new Scanner(System.in);
//当程序执行到 next 方法时，会等待用户输入~~~
String name = myScanner.next(); //接收用户输入字符串
int age = myScanner.nextInt(); //接收用户输入 int
double sal = myScanner.nextDouble(); //接收用户输入 double

五、进制

表示方式

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

进制转换

二进制转十进制
规则:从最低位(右边)开始，将每个位上的数提取出来，乘以2的(位数-1)次方，然后求和。
0b1011转成十进制的数
0b1011 = 12的(1-1)次方+ 1 * 2的(2-1)次方+ 0 * 2的(3-1)次方+ 1
2的(4-1)次方法= 1 + 2 + 0+ 8= 11
八进制转十进制
规则:从最低位(右边)开始，将每个位上的数提取出来，乘以8的(位数-1)次方,
然后求和。
0234转成十进制的数
0234= 48^0+3*81+28^2-4+ 24+128= 156
十六进制转十进制
规则：从最低位(右边)开始，将每个位上的数提取出来，乘以 16 的(位数-1)次方，然后求和。
0x23A 转成十进制的数
0x23A= 10 * 16^0 + 3 * 16 ^ 1 + 2 * 16^2 = 10 + 48 + 512 = 570

十进制转二进制
规则：将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
34 转成二进制 = 0B00100010
十进制转八进制
规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
131 转成八进制 => 0203

二进制转八进制
规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可。
ob11010101 转成八进制
ob11(3)010(2)101(5) => 0325
二进制转十六进制
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
ob11010101 转成十六进制
ob1101(D)0101(5) = 0xD5

八进制转二进制
规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。
0237 转成二进制
02(010)3(011)7(111) = 0b10011111
十六进制转二进制
规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。
0x23B 转成二进制
0x2(0010)3(0011)B(1011) = 0b001000111011

位运算

   public static void maiin(String []args)
   {
   int a=1>>2; // 1 向右位移 2 位
   int b=-1>>2;//算术右移
   int c=1<<2;//算术左移
   int d=-1<<2;//
   int e=3>>>2;//无符号右移
   //a,b,c,d,e 结果是多少
   System.out.println("a="+a);
   System.out.println("b="+b);
   System.out.println("c="+c);
   System.out.println("d="+d);
   System.out.println("e="+e);
   }
   ``
   ~2=? // 按位取反
    //推到
    //1.得到2的源码 00000000 00000000 00000000 00000010
    //2.~2操作     11111111 11111111 11111111 11111101 运算后的补码
    //3.运算后的反码 11111111 11111111 11111111 11111100
    //4.运算后的源码 10000000 00000000 00000000 00000011 =》-3
   2&3=?// 2 按位与 3
   2|3=? //2按位或3
   ~-5=? //
   13&7=?
   5|4=? 
   -3^3=?//^ 按位异或

二进制在运算中的说明

1.二进制是逢2进位的进位制，0、1是基本算符。
2.现代的电子计算机技术全部采用的是进制，因为它只使用0、1两个数字符号，
非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制
数来表示的。二进制(Binary) 数用0和1两个数字及其组合来表示任何数。进位
规则是"逢2进1",数字1在不同的位上代表不同的值，按从右至左的次序，这个
值以二倍递增

原码、反码、补码
对于有符号的而言:
1.二进制的最高位是符号位: 0表示正数，1表示负数(老韩口诀: 0->0 1-> -)
2.正数的原码，反码，补码都样(三码合一)
3.负数的反码=它的原码符号位不变，其它位取反(0->1,1->0)
4.负数的补码=它的反码+1，负数的反码=负数的补码- 1
5.0的反码，补码都是0
6. java没有无符号数，换言之，java中的数都是有符号的
7.在计算机运算的时候，都是以补码的方式来运算的
8.当我们看运算结果的时候，要看他的原码(重点)

位运算符

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

分别是按位与&、按位或|、按位异或^ ,按位取反~ ,它们的运算规则是:
按位与& ：两位全为1,结果为1，否则为0
按位或| ：两位有一个为1,结果为1,否则为0
按位异或^ : 两位一个为0,一个为1,结果为1,否则为0
按位取反~ : 0->1 ,1->0
比如: 2&3=? ~-2 = ? ~2=? 2|3=? 2^3=?

还有 3 个位运算符 >>、<< 和 >>> , 运算规则:

算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位
算术左移 <<: 符号位不变,低位补 0
逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0
特别说明：没有 <<< 符号

int a=1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0
int c=1<<2; //1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4

六、程序控制结构

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

顺序控制
分支控制
循环控制

顺序控制

程序从上到下逐行执行，中间没有任何判断和跳转。

java中定义变量时采用向前引用：

即先定义后使用

分支控制 if-else

分支控制 if-else 让程序有选择的的执行,分支控制有三种

单分支 if
双分支 if-else
多分支 if-else if -…-else

单分支

基本语法
if(条件表达式){
		执行代码块；
}

当条件表达式为true是，就会执行{ }中的代码。如果为false，就不执行。

双分支

基本语法

if(条件表达式){
	执行代码块； 
}else{
	执行代码块2；
}

当条件表达式成立时，即执行代码块1，否则执行代码块2

多分支

基本语法

if(条件表达式1){
	执行代码块； 
}else if(条件表达式1){
	执行代码块2；
}
......
else{
	执行代码块n;
}

如果没有else，如果所有条件表达式都不成立，则一个直行入口都没有
如果有else，如果所有条件表达式都不成立，则默认执行else代码块

嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议: 不要超过 3 层（可读性不好）

基本语法
if(){
	if(){
		//if-else...
	}else{
		//if-else
	}
}

switch分支结构

基本语法
switch(表达式){
	case 常量1：
	代码块1；
	break；
	case 常量2：
	代码块2;
	break;
	......
	default:
	代码块；
	break；
}
1. switch关键字，表示swtich分支
2.表达式对应个值
3. case常量1 :当表达式的值等于常量1,就执行语句块1
4. break :表示退出swtich
5.如果和case常量1匹配，就执行语句块1,如果没有匹配，就继续匹配case常量2
6.如果一一个都没有匹配上，执行default

switch 注意事项和细节讨论

1.表达式数据类型，应和case后的常量类型一致，或者是课一自动转成可以相互比较的类型，比如输入的是字符，而常量是int
2.switch（表达式）中表达式的返回值必须是:(byte,short,int,char,enum[枚举]，String)
3.case自居中的值必须是常量，而不能是变量
4.default字句是可选的，当没有匹配的case时，执行default
5.break语句用在执行完一个case分枝后使得程序跳出switch语句块，如果没有break，程序会顺序执行到switch结尾，除非遇到break；

switch 和 if 的比较

如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。
其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广

for 循环控制

基本语法
for(循环变量初始化；循环条件；循环变量迭代){
循环操作(可以多条语句)；
}

for 关键字，表示循环控制
for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
如果循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略

 public class 惩罚口诀表 {

    public static void main(String[] args) {

        for (int i= 1; i < 10; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

注意事项和细节说明

循环条件是返回一个布尔值的表达式
for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

while 循环控制

基本语法
while(循环条件){
	循环体(语句)；
	循环变量迭代；
	}

注意事项和细节说明

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

do…while 循环控制

基本语法
循环变量初始化;

do{
	循环体( 语句);
	循环变量迭代;
}while(循环条件);

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

注意事项和细节说明

循环条件是返回一个布尔值的表达式
do…while 循环是先执行，再判断，因此它至少执行一次

多重循环控制

介绍

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

跳转控制语句-break

基本语法：
{ ……
	break;
	……
}

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

跳转控制语句-continue

基本语法：
{ ……
	continue;
	……
}

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

跳转控制语句-return

return的常用作用有以下两种:
第一种用法是，方法的结束。
比如当代码执行到某个地方会出现几种结果，然后其中一种结果就不能执行后续代码，这时候在那里加上一个“return;”就可以终止后面的代码执行。
return 使用在方法，表示跳出所在的方法。

第二种是返回方法指定类型的值（这个值总是确定的），也可以是对象
public string functionTest(){
return a;
}
那么这个方法被调用之后就会返回一个值为abc的字符串，

七、数组

数组介绍

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

使用方式1

数组定义:

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

先声明数组
语法:数据类型数组名[]; 也可以数据类型[] 数组名;
int a[]; 或者 int[] a;
创建数组:
语法: 数组名=new 数据类型[大小];
a=new int[10];

数组初始化
数组类型数组名[] ={元素值,…}

数组使用注意事项和细节

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

创建一个 char 类型的 26 个元素的数组，分别放置’A’-‘Z’。
使用 for 循环访问所有元素并打印出来。

例：
1. 定义一个 数组 char[] chars = new char[26]
2. 因为 'A' + 1 = 'B' 类推，所以老师使用 for 来赋值
3. 使用 for 循环访问所有元素
   */
   char[] chars = new char[26];
   for( int i = 0; i < chars.length; i++) {//循环 26 次
   //chars 是 char[]
   //chars[i] 是 char
   chars[i] = (char)('A' + i); //'A' + i 是 int , 需要强制转换
   }
   //循环输出
   System.out.println("===chars 数组===");
   for( int i = 0; i < chars.length; i++) {//循环 26 次
   System.out.print(chars[i] + " ");
   }
   }
   }

数组赋值机制

基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
int n1 = 2; int n2 = n1;
数组在默认情况下是引用传递，赋的值是地址。
//代码 ArrayAssign.java
int[] arr1 = {1,2,3};
int[] arr2 = arr1;

数组拷贝

编写代码实现数组拷
//创建一个新的数组,开辟新的数据空间
//遍历原数组，把每个元素拷贝到新数组对应的元素位置

数组反转

//定义数组
int[] arr = {11, 22, 33, 44, 55, 66};
//使用逆序赋值方式
//1. 先创建一个新的数组 arr2 ,大小 arr.length
//2. 逆序遍历 arr ,将每个元素拷贝到 arr2 的元素中(顺序拷贝)
//3. 建议增加一个循环变量 j => 0 => 5
int[] arr2 = new int[arr.length];
//逆序遍历 arr

数组添加/扩容

要求：实现动态的给数组添加元素效果，实现对数组扩容。

数组拷贝

在java里，允许将一个数组变量拷贝给另一个数值变量。此时，两个变量将引用同一个数组。
数组拷贝

intint[]a=new int[4];
int[]b=a;
a[1]=4;//现在b[1]也等于4

在java里，允许将一个数组变量拷贝给另一个数值变量。此时，两个变量将引用同一个数组。
int[] copy = Arrays.copyOf(array,2*array.length);//第一个参数是待拷贝的int型的数组对象，第二个是新数组的长度
使用动态的ArrayList类
在java里，有一个ArrayList的泛型类，也被叫做数组列表，它使用起来有点像数组，但是在添加或删除元素时，具有自动调节数组容量的功能，而不需要编写另外的代码。
ArrayList staff =new ArrayList<>();

数组排序

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

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

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

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

int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110};
int temp = 0; //用于辅助交换的变量
//将多轮排序使用外层循环包括起来即可
//先死后活 =》 4 就是 arr.length - 1
for( int i = 0; i < arr.length - 1; i++) {//外层循环是 4 次
	for( int j = 0; j < arr.length - 1 - i; j++) {//4 次比较-3 次-2 次-1 次
		//如果前面的数>后面的数，就交换
		if(arr[j] > arr[j + 1]) {
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
		}
	}

数组查找

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

顺序查找
二分查找

标准的二分查找
二分查找左边界
二分查找右边界
二分查找左右边界
二分查找极值点

class BS {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target) return mid;
            else if (nums[mid] > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
}

循环条件： left <= right
中间位置计算： mid = left + ((right -left) >> 1)
左边界更新：left = mid + 1
右边界更新： right = mid - 1
返回值： mid / -1

多维数组-二维数组

使用方式 1: 动态初始化

语法: 类型[] []  数组名=new 类型[大小][大小]

比如: int a[] [] = new int[2][3]

使用方式 2: 动态初始化

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

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

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

使用方式 4: 静态初始化

定义类型数组名[][] = {{值 1,值 2…},{值 1,值 2…},{值 1,值 2…}}
使用即可 [ 固定方式访问 ]
比如:
int[][] arr = {{1,1,1}, {8,8,9}, {100}};

定义了一个二维数组 arr
arr 有三个元素(每个元素都是一维数组)
第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组有 1 个元素

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

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

JavaAPI 文档

API (Application Programming Interface,应用程序编程接口)是Java提供的基本编程接口(java提供的类还有相关的方法)。中文在线文档:
https://www.matools.com
Java语言提供了大量的基础类，因此Oracle公司也为这些基础类提供了相应的API文档，用于告诉
开发者如何使用这些类，以及这些类里包含的方法。
Java类的组织形式[java类的组织形式]
4.举例说明如何使用ArrayList类有哪些方法.
安包>类->方法
直接索引. Math

ASCII 码了解

ASCII码:上个世纪60年代，美国制定了一套字符编码(使用个字节)，对英语字
符与二进制位之间的关系，做了统规定，这被称为ASCI码. ASCI码共规走
了128个字符的编码，只占甩了一个字节的后面7位，最前面的1位统规定为0。
特别提示:一个学书可以表示256个学符，ASCII码只用了128个字符
2.看完整的ASCII码表
3.缺点:不能表示所有字符。

Unicode 编码

Unicode的好处: 一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独
-无二的编码，使用Unicode没有乱码的问题。
Unicode 的缺点:一个英文字母和一个汉字都占用2个字节，这对于存储空间来说是浪费。
3.2的1 6次方是65536,所以最多编码是65536个字符。
4.编码0-127的字符是与ASCII的编码样比如’a’ 在ASCII码是0x61，在unicode码是
0x0061,都对应97.因此Unicode码兼容ASCII码.

UTF-8 编码

UTF-8是在互联网上使用最广的一种Unicode的实现方式(改进)
UTF-8 是一种变长的编码方式。它可以使用1-6个字节表示个符号，根据不
同的符号而变化字节长度。
3.使用大小可变的编码字母占1个字节，汉字占3个字节

面向世界编程

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【无标题】

一、java特点1、java语言是面向对象的（oop）2、java语言是健壮性的，Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证3、 Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台]4、 Java 语言是解释型的解释性语言：javascript,PHP, java 编译性语言: c / c++区别是：解释性语言，编译后的代码，不能直接被机器执行,需要解释器来执行, 编译性语言, 编译后的代码, 可
复制链接

扫一扫