疯狂Java——day01

78 阅读 0 评论 52 点赞

我是靠谱客的博主迷你橘子，最近开发中收集的这篇文章主要介绍疯狂Java——day01，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

编译java程序

命令：

javac -d <目录> 源程序 // 指定。.class文件位置

运行java程序

命令：

java 主类

可运行的类必须包含main方法。

jshell工具

交互式工具，从java9开始。

命令：

jshell

java注释

单行注释：// 注释内容

多行注释：/* */

文档注释：javadoc工具可以提取文档注释来生成API文档。

/**
*
*
*/

API文档：为java类提供的使用说明书。

文档注释：文档注释只有放在类、成员变量、方法、构造器、内部类之前才有意义！javadoc默认只提取public和protected成员之前的文档注释。

生成文档注释

javadoc -d <目录> 源文件 //-d指定“API”文档存放的位置

变量

用于装数据，变量相当于一个容器。

声明变量

类型变量名 [= 初始值]；

标识符（就是名字）

由字母、下划线、数字、$组成，但数字不能开头。不能使java的保留字。

可为变量、类、方法。。。。起名字

关键字：都是小写的。

保留字：goto,const.

一共有53个单词作为标识符。

包括基本类型和引用类型

基本类型：

整型：只能正整数和负整数和0 。bit（位）要么0，要么1; 字节（Byte）8个bit(能表示256个数)

2^20=>M 2^30=>G 2^40=>T

byte: 字节,8个bit(能表示256个数),取值范围：-128~127

short: 16位（能够表示65536个数）、取值范围：-32768~32767

int : 32位（能够表示4G个数）、取值范围：-2G~2G-1

long: 64位。

注意点：
- 你直接给一个整数。整数默认是Int型。
  
  如果该整数较小、且直接赋值给byte或short、java也可以将它当成byte、short处理。
- 如果你直接给出一个巨大的整数，java不会自动把他当成long型处理。
  
  如果希望java把改整型当成long处理，需要在整数后添加L或l后缀。
- 整数一共有四种表示形式：
  
  十进制
  
  八进制：以零开头、逢8进1、只能出现0~7.
  
  十六进制：以0X开头或0x开头、逢16进1、只能出现0_9、af
  
  二进制：以0B或0b开头、逢2进1、只能出现0~1。
  
  十六进制的数，在编程中常常用——每位十六进制的数，恰好换算成4位二进制数，非常方便。
浮点型：

只能带小数部分的数。java的浮点型只有两个：

float: 4个字节（32位）：取值更大

double: 8个字节（64位）：取值超大

编程时使用double，因为浮点型有精度损失，而float损失更严重。
- 注意点：
  - 如果直接给一个浮点数，默认是double类型。如果你希望一个浮点数被当成float处理，必须在浮点值后添加F或f。
  - 浮点数有精度损失、所以浮点数比较时，应该使用“差值法”
  - 浮点数有两种形式：
    - 小数形式
    - 科学计数法
  - 浮点数值有3个特殊值：
    
    浮点数除以0，得到无穷大。
    
    正无穷大：正正得正，负负得正
    
    负无穷大：正负得负
    
    所有正无穷大都相等，所有负无穷大都相等
    
    非数：浮点0除以0，对负数开方。得到的就是非数。
    
    非数与任何数都不想等，与他自己也不相等。
字符型：

只能装单个字符（英文、中文、日文。。。）且单个字符放在单引号里。

char:2个字节（16位）

注意：
- 字符型有三种表示形式：
  - 单引号里放普通字符。
  - 单引号里放特殊的转义字符。java的转义字符参考教材P52
  - 用字符的Unicode编号。十六进制
- 字符可以当成无符号整数使用。使用的是该字符的编号。取值范围（）
字符集：为了计算机底层保存字符。为所有字符编号，需要保存字符时，实际上保存的是该字符的编号（二进制）。读取字符内容时，读取的是二进制的编号，还需要参照编号才能找到对应的字符。
- ASCII：只支持英文、数字、标点符号，♠，♥，♦，????
  
  a-z:97~97+25 A_Z:6590 0_9:4857
  
  r: 13 n: 10 ': 39 ": 34
- GB2312:简体中文字符集
- GBK：国标扩大
- GB18030：目前简体的字符集。
boolean型

只有2个值：true和false
类型转换
- 自动转换：取值范围小的可以直接转换为范围大的。
  
  byte -> short（-32768~32767） -> int -> long -> float -> double
  
  char (0~65535) /
  
  推论：所有的整型都可以自动转换成浮点型。
  
  所有的数值型都可以转double型
- 强制转换：上图反过来就需要强制类型转换。double不能自动转int
  
  int it = (int)5.9;//直接砍掉小数点后的部分
  
  可能发生“溢出”
  - 溢出规则：用该数-目标函数的大小*n,保证减出来的差在取值范围内
```
int e = 1333;
byte f = (byte)e;
//1333-256*4=309	->	309-256=53
```
- 表达式类型的自动提升
  
  整个表达式的类型,和该表达式中最高等级的操作数的类型相同。
  
  byte b = 97 + 1;//在编译时就会算出98,98在byte表示的范围（-128~127）内，不会报错。但是：
  
  byte b = 127 + 1;//128会报错
  
  byte b = 126 + 1;//127不会报错
  
  面视题：
```
byte a = 2;
a = a + 1;
System.out.println(a);
```

使用var定义变量

从java10开始才引入的特征。

语法为：var 变量名 = 初始值

var并不是关键字，是一种动态类型，var动态类型将会有java的编译器根据变量的【所赋的值】来推断其类型。
为何引入var？

很多语言（Kotlin、Js等）都支持var变量，java 10为了迎合普通开发者，才引入var

java没有全局变量一说。
使用var注意点：
- var只能在方法中定义变量，不能在类中定义成员变量。
- var声明的变量，必须在声明时指定初始值
- var每次只能声明一个变量。如：var c =12,b=3;×，不允许在符合声明中使用。
使用var优缺点：

优点：编程简洁，代码整齐。

缺点：会降低程序的可读性。
何时不因该使用var声明变量？

声明变量时，指定了一个直观初始值（2，“打分”，3.3），此时可以使用var

不应该使用2处：
- 变量所赋的值是很复杂的方法调用，类型不直观时。
  
  var a = def(abc().xyz()); // 此处a的类型很难看出，因此不应该使用var声明。
- 当你的变量的作用域很大时，方法很长，var变量影响深远，不应该使用。

随机验证码

import java.util.Random
public class 随机验证码
{
	public static void main(String[] args)
	{
	    //原理
		//int d = 100;
		//char c = (char)d;
		//System.out.println(c);
		
		//假如生成随机的小写字符：97~97+25 
		Random rnd = new Random();
		rnd.nextInt(26) + 97;
		char c = (char)d;
		System.out.print(c);
		
	}
}

运算符

+，-，*，/，%

++：将单个变量的值加1；

– ：将单个变量的值减1；

boolean值不可以加减；

对于一些更复杂的运算，应该使用Math类，（不用手动导入）

//计算乘方
Math.pow(3,8);
//开方
Math.sqrt(25);
//四舍五入
Math.round(3.3);
//向下取整
Math.floor(-4.5);//-5
//向上取整
Math.ceil(4.4);

赋值运算符：=

右边的值赋给左边。右边可以是简单值、表达式。左边只能是变量。

比较运算符

  >	>=	<	<=	==	!=
  结果为true或false

逻辑运算符

只能对boolean值进行运算。

&& 与两个都为true才为true

//短路
int a = 10;
int b = 5;
boolean ne = a > 15 && b++ >2;
System.out.println(bn);//false
System.out.println(bn);//b还是5，说明b++没有执行

& 不短路与

|| 或一个为true，就为true

| 不断路或

！非

^ 异或：两个条件相同得到false,不同得到true

扩展的赋值运算符（快）

a += b a = a + b;

a -= b;

a *= b;

扩展的赋值运算符的左边只能是变量

三目运算符

int s = 4000
String ss = s > 12000 ? "收入还行，可以买买买":"只能吃土"; 
String sss = s > 12000 ? "收入高，可以买买买":(s > 3000 ? "收入还行":"只能吃土"); //嵌套

逻辑表达式？值1：值2

表达式为true,返回值1，否则返回值2

运算符的优先级和结合性

结合性：大部分运算符从左向右，赋值运算符从右向左。

优先级：先乘除，后加减。用括号保证优先级。

位运算符

按位与 &:两个对应位都为1，结果才为1
按位或 | :两个对应位有一个为1，结果就为1

当表示状态时，会用特定的数代表开关。文本状态：粗体（1）、斜体（2）、下划线（4）

001 010 100

负数的进制码：保存的是补码。

原码：数，直接算出来的叫原码，最高位又叫符号位。0表示正数，1表示负数

反码：除符号位之外，其他位都按位取反。

补码：反码+1

//int是32位
/*
0000_0000_0000_0000_0000_0000_0001_0111  //23=16+4+2+1
0000_0000_0000_0000_0000_0000_0100_0101  //69=64+4+1
0000_0000_0000_0000_0000_0000_0000_0101  //&:1+4=5 
0000_0000_0000_0000_0000_0000_0101_0111  //|:1+2+4+16+64=87

1000_0000_0000_0000_0000_0000_0001_0111  //-23的原码
1111_1111_1111_1111_1111_1111_1110_1000  //23的反码
1111_1111_1111_1111_1111_1111_1110_1001  //-23的补码

0000_0000_0000_0000_0000_0000_0100_0101  //69的原码、补码
----------------------------------------------------------------------
1111_1111_1111_1111_1111_1111_1110_1101  //计算结果（补码）
1111_1111_1111_1111_1111_1111_1110_1100  //计算结果（补码-1=反码）
1000_0000_0000_0000_0000_0000_0001_0011  //计算结果 （原码）


*/
System.out.println(23 & 69);//5
System.out.println(23 | 69);//87
System.out.println(-23 | 69);//-19

~ 按位取反。原来是0变成1，原来是1变成0；正数变成负的（绝对值+1），负数变成正的（绝对值-1）。

System.out.println(~5);//-6
System.out.println(~93);//-94
System.out.println(~-93);//92
System.out.println(~-87);//86

^ :按位异或。上下两位相同得0，不同得1；

/*
0000_0000_0000_0000_0000_0000_0011_1000  //56的原码
0000_0000_0000_0000_0000_0000_0101_1001  //89的原码
0000_0000_0000_0000_0000_0000_0110_0001	 //97
*/

System.out.println(56^89);//97

<< 左移：左移N位，相当于乘以2的N次方。

面视：2*8的最快实现是：2 << 3
“>> 右移：右移N位，相当于除以2的N次方。除不尽时，实际结果总是比实际结果略小的整数”
```
System.out.println(34 >> 3);//4
int a = 3;
a << 1;//扩大一倍.
```
">>> :无符号右移。如果被移的数是正数，那么该运算符与>>效果一致。

如果被移的数是负数，被空出来的高位总是补0----这个数就会变成正数。