java基础2

最新推荐文章于 2024-08-26 13:32:01 发布

jdk大白

最新推荐文章于 2024-08-26 13:32:01 发布

阅读量140

点赞数

本文链接：https://blog.csdn.net/weixin_42426234/article/details/106669398

版权

注释
- 3种
- 单行注释 // 只能一行
- 多行注释 /**/ 可以多行，但不能嵌套
- 文档注释 /** */ 用于自动生成帮助文档
- 进行说明备注，可以出现在代码的任何地方。java编译器在编译的过程中会忽略
- 可以进行代码的调试
关键字
- java中有特殊含义的单词，特点：全部小写
- 一同有53个。 const 和 goto 是保留字，也不能使用。
- 已经学过的：class public static void true false null byte short int long float double char boolean
标识符
- 需要给程序中起名字的地方。
- 组成：
  - 字符（英文大小写）
  - 数字
  - $ _
- 约束：
  - 不能是关键字
  - 首字符不能是数字
  - 严格区分大小写
- 规范：
  - 类名、接口名：首字母大写
  - 方法名、局部变量名、成员变量名：第一个单词首字母小写。后面第二个以后首字母大写。
  - 常量：每个单词全部大写，多个词之间用下划线分隔
  - 包名（文件夹的名字）：全部小写
常量
- 字面值常量
  - 字符串 "" 内容
  - 字符 '' 内容，只能是单个字符
  - 整数：跟数学一致。对应 int
  - 小数：跟数学一致。对应 double
  - 空常量 null
  - 布尔： true false
- 进制表示
  - 二进制 0b 开头的数字
  - 八进制 0 开头的数字
  - 十六进制 0x 开头的数字
- 存储
  - Java中所有的类型都是有符号的类型
  - 存储都是补码的形式
    - 正数：原码、反码、补码都一样
    - 负数：原码（二进制）、反码（符号位不变，其它位取反）、补码（符号位不变，反码加1）
- 自定义常量
变量
- 在程序执行过程中，值可以发生改变。
- 变量其实就是对内存中的一块区域起了个名字
- 格式： 数据类型变量名=初始值
- 变量名按标识符的规则走就可以了
- 初始值，可以是其它变量，也可以是字面值常量。
- ```
int b = 3;
int c = b;
```
- 同一个范围内（不能定义相同名称的变量）
- 数据类型
  - 基本数据类型
    - 四类八种
    - 整数： byte[1字节, -128 127] short [2字节,-32768 32767]int[4字节, 21亿] long [8字节]
    - 浮点数 float[4字节] double [8字节]
    - 字符 char [2字节]
    - 布尔 boolean
    - 首先byte、short、int、long都是整数类型。
  ①：byte占一个字节,也就是8位,而且byte 是有符号整形用二进制表示时候最高位为符号位 0代表正数 1代表负数。

max:01111111(十进制：2^8-1=127)

min:是11111111吗？答案不是的。8位总共能表示256个数。00000000表示0，那10000000表示？

要注意正数在计算机中是以原码形式存在的，负数在计算机中是以其补码形式存在的，那么一个负数的补码是怎么计算的呢？就是负数的绝对值的原码转为二进制再按位取反后加1。

-128的绝对值128，128源码10000000 取反：01111111 加1:10000000 故-128计算机中的表示就是 1000 0000 了。

-2^{7(-128)<byte<2}7-1(127)

jdk中 Byte.class中的源代码：

/**
* A constant holding the minimum value a byte can
* have, -2⁷.
/
public static final byte MIN_VALUE = -128;
/*
* A constant holding the maximum value a byte can
* have, 2⁷-1.
/
public static final byte MAX_VALUE = 127;
②同理：short占2位，int占4位，long占8位，都是有符号整型。
/*
* A constant holding the minimum value a short can
* have, -2¹⁵.
*/
public static final short MIN_VALUE = -32768;

/**
 * A constant holding the maximum value a <code>short</code> can
 * have, 2<sup>15</sup>-1.
 */
public static final short   MAX_VALUE = 32767;
                                 -2^15(-32768)<byte<2^15-1(32767)

/**
* A constant holding the minimum value an int can
* have, -2³¹.
*/
public static final int MIN_VALUE = 0x80000000;

/**
 * A constant holding the maximum value an <code>int</code> can
 * have, 2<sup>31</sup>-1.
 */
public static final int   MAX_VALUE = 0x7fffffff;
                        -2^31(-2147483648)<byte<2^31-1(2147483647)

/**
* A constant holding the minimum value a long can
* have, -2⁶³.
*/
public static final long MIN_VALUE = 0x8000000000000000L;

/**
 * A constant holding the maximum value a <code>long</code> can
 * have, 2<sup>63</sup>-1.
 */
public static final long MAX_VALUE = 0x7fffffffffffffffL;
                                   -2^63<byte<2^63-1

char作为16位无符号整形其范围为 0 —— 2^15，float占4位，double占8位。

* 引用数据类型（无限多）

  * 类、接口、【数组】

* 默认转换

  * `byte` `short` `char` 参与计算的时候，都会先转换为int 

  * 小的类型可以自动转换为大的类型

    * `byte` `short` /`char`  `int` `long` `float` `double` 

  * 当大的类型赋值给小的类型的时候，需要强制转换

    * `小的数据类型 变量名= （小的数据类型） 大的类型的值` 

  * ```java
    byte a = 3 ,b = 4 , c ;
    c = a+b ;//错误
    c = 3+4; //正确
    c = 127+1 ;// 错误
    c  = 128 ;//错误
    
    //记住是小于int类型的规则
    ```

  * ```
    int a = 2222+2222222; //正确
    int a = 222222222222;//错误
    ```

* 字符类型参与计算，转换它的编码，然后再计算

  * ASCII码 兼容任何编码。 
  * 常见的ASCII码 【65 - A】【97- a】【48-0】

字符串参与+运算符

当字符串参与 + 运算的时候， + 的意思就变成了 拼接 结果是一个字符串。

System.out.println("hello"+"world");// helloworld
System.out.println("hello"+'a'); //helloa
System.out.println("hello"+'a'+1);// helloa1
System.out.println('a'+1+"hello");// 98hello
System.out.println("5+5="+5+5);//5+5=55   “5+5=5”+5  -> “5+5=55”
System.out.println(5+5+"=5+5");// 10=5+5

运算符

主要是对常量和变量进行操作的过程称为运算。

具有有什么类型的操作，由运算符来决定。

操作数，是被运算符操作的哪些变量或常量。

算术运算符

+ 操作数是1的时候，表示正号。
- 操作数是1的时候，表示负号。
+ 操作数是2的时候
- 是否有字符串参与，表示拼接
- 如果没有，表示加法
- 操作数是2时，表示减法
* 表示乘法
/ 表示除
- 当两个操作数都是整数时，是整除（只取整数部分）
- 当两个操作数至少有一个是浮点数时，结果跟数学上一致。
% 表示取余数
++ 表示在原有基础上加一。只能操作变量。
-- 表示在原有基础上减一。只能操作变量。
- 当它们写在变量的前面的时候，是先增减，再获取。
- 当它们写在变量的后面的时候，是先获取，再增减。
- 最终的效果是一样的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Y113RJg-1591776723551)(imges/image-20200610103650809.png)]

赋值运算符

所有的赋值运算都要看成动词（动作），从右往左看。

= 是将等号右边的结果存入等号左边。
+=
-=
*=
/=
%=

short s  = 1 ; //可以吗？可以。
s+=1;//可以吗？ 可以
System.out.println(s);//2

System.out.println("------------");
//s=s+1; //可以吗？ 不可以。必须强转
s=(short)(s+1); //必须这样做
System.out.println(s); //3

+= 之类的运算符是一个整体。

比较运算符

== 相等比较才是我们之前熟悉的数学上的 =
!= 不等
> 大于
< 小于
>= 大于等于
<= 小于等于
instanceof 关键字。后面面向对象再用。

统一的特点：所有的比较运算结果都是布尔值。

逻辑运算符

& 逻辑与（并且）
| 逻辑或 (或者)
^ 逻辑异或
! 非
&& 与（并且)
|| 或（或者）

真和假

A 或 B 为真的条件是：至少有一个为真，结果为真。

A 或 B 为假的条件是：两个必须全为假，结果为假。

A 且 B 为真的条件是：两个必须全为真，结果为真。

A 且 B 为假的条件是：至少有一个为假，结果为假。

非A 为真的条件： A是假

非A 为假的条件： A是真

|| 和 | 以及 && 和 & 的区别：

它们的计算结果都是一样的。
两个的写法会发生“短路” ，只要事先能确定最终的结果，就不会去计算其他的部分。
而一个的写法，是“弱智” ，全部算完每部分以后，再来确定最终的结果。

所以，一般推荐用两个的。

按位与： bit位存储的都是1的时候，结果为1 。否则为0。

按位或：bit位存储的都是0的时候，结果为0。否则为1。

按位异或： bit为存储的数据不一样的时候，结果才为1。一样的时候，为0 。

男女关系。男和女配 ok。男和男、女和女配不ok。

位运算符【了解】

>> 按位右移（1位就相当于除2）
<< 按位左移（1位就相当于乘2）
~ 取反码
>>> 无符号右移

异或的特点：一个数对另外一个数异或两次，该数本身不变。

int a = 10;

int b = 20;

a ^ b ^ b ------ 10

a ^ b ^ a ----- 20

三目运算符

格式：

(关系表达式  结果是布尔值) ？ 表达式1 ： 表达式2;

意思：

如果前面的关系成立，则返回表达式1的值。

否则，返回表达式2的值。

int a = 20;
int b = 40;

//返回两者中较大的数：
int max = (a>b) ? a : b;
System.out.println("较大的数是:"+max);

控制台读取用户输入

分3步：

第一步：导入工具。import java.util.Scanner 要写在class的外面。
第二步：把工具准备好。 Scanner 工具变量名 = new Scanner(System.in)
第三步：通过工具接收读取到的内容。 工具变量名.nextInt()

import 也是一个关键字。

练习：使用输入的功能完成：

1）用户输入两个数，返回这两个数的求和

2）用户输入两个数，你来返回这两个数是否 “相等”

import java.util.Scanner;
class asd{

	  public static void main(String[]args){
	Scanner g=new Scanner(System.in);
	System.out.println("输入第一个数:");
	int a=g.nextInt();
	System.out.println("输入第二个数:");
	int b=g.nextInt();
	int sum=a+b;
     System.out.println("输入和:"+sum);
	 
	  System.out.println(a==b ?"相等:":"不相等");
	  }	
}
# 控制台读取用户输入

程序的流程控制语句

只要使用三种类型：

顺序结构
分支结构
循环结构

就可以描述任意复杂的逻辑。

顺序结构

没有特定的Java语法的规定。是最简单的一种语句结构。它的特点：是写在最前面的代码先执行，后面的代码后执行
在这里插入图片描述

分支（选择）结构

它的走向主要取决于某个判断。根据判断结果的不同，程序会执行不同的逻辑部分。在Java语言中，分支结构又分为：

if 语句
switch 语句

if 和 switch 是关键词。

if的第一种结构

if(关系表达式：布尔值){
语句体;
}
在这里插入图片描述
注意事项：

关系表达式，可以任意复杂。但是不论多复杂，都需要返回一个布尔值。
如果这个语句体中只有一条指令（只有一个分号）时，大括号可以省略。
- 但是，当如果包含多条指令的时候，大括号不可以省略。
- 推荐总是加上大括号。在这里插入图片描述
  if(a==b);{
  System.out.println(“相等”);
  }

//理解

if(a==b)
; //相当于只有一条指令（啥也没干），这时大括号可以省略

//下面这个是定义了一个语句块（作用域）
{
System.out.println(“相等”);
}

//总结：一般有左大括号，就没有分号。有分号就没有左大括号。
if(关系表达式：布尔){
if(关系表达式：布尔){
语句体1;
}else{
语句体2;
}

跟三目运算符的比较

从执行流程上来看，if的第二种结构跟三目运算符很像。

结论：

能用三目运算符实现的功能，一定能用if来实现。
反之，不然。

if的第三种结构

if(关系表达式1:布尔值){
语句体1;
}else if(关系表达式2:布尔值){
语句体2;
}…else if(关系表达式N：布尔值){
语句体N;
}

//---------
if(关系表达式1:布尔值){
语句体1;
}else if(关系表达式2:布尔值){
语句体2;
}…else if(关系表达式N：布尔值){
语句体N;
}else{ //最后一个else 不带条件
语句体N+1;
}

根据学生的成绩：输出优良中差

90以上优秀

80-90 良好

60-80 中等

60以下差等
public static void main(String[] args){

	int score = 90;
	
	/*
	if(score>=90){
		System.out.println("优秀");
	}else if(score>=80 && score<90){
		System.out.println("良好");
	}else if(score>=60 && score<80){
		System.out.println("中等");
	}else if(score<60){
		System.out.println("差等");
	}*/
	
	//优化1： 去掉默认条件
	if(score>=90){
		System.out.println("优秀");
	}else if(score>=80 && score<90){
		System.out.println("良好");
	}else if(score>=60 && score<80){
		System.out.println("中等");
	}else{
		System.out.println("差等");
	}
	
	//优化2：【重点】 隐含条件 对立面（不成立） 不需要再次指定
	if(score>=90){
		System.out.println("优秀");
	}else if(score>=80){
		System.out.println("良好");
	}else if(score>=60){
		System.out.println("中等");
	}else if(score<60){
		System.out.println("差等");
	}
}