计算机存储规则是指在计算机中,任意数据都是以二进制的形式来存储的。
二进制0b:由0和1组成
十进制: 由0~9组成
八进制0:由0~7组成
十六进制0x:由0~9还有a~f组成

GB2312编码:1981年5月1日发布简体中文汉字编码国家标准。收录7445个图形字符,包括6763个汉字。
BIG5编码:台湾地区繁体中文标准字符集,共收录13053个中文字,1984年实施。
GBK编码:2000年3月17日发布,收录21003个汉字,包含国家标准GB13000-1中的全部中日韩汉字,和BIG5编码中的所有汉字。
Unicode编码:国际标准字符集,它将世界各种语言的每个字符定义一个唯一的编码,以满足跨语言、跨平台的文本信息转换。
注释
注释是在程序指定位置添加的说明性信息简单理解,就是对代码的一种解释。不管是单行注释还是多行注释,在书写的时候都不要嵌套
// 这是一个单行注释
/* 这是一个多行
多行注释 */
/**
* 这是一个文档注释
*
* 作者 尼古拉斯•阿玮
*
* version 1.0
*/关键字
关键字是被Java赋予了特定涵义的英文单词,字母全部小写。常用的代码编辑器,对关键字有特殊颜色标记。class关键字表示定义一个类,后面跟随类名。
48个关键字:
abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while
2个保留字:
goto const
3个特殊直接量:
true、false、null
字面量
字面量是告诉程序员:数据在程序中的书写格式。
| 类型 | 说明 | 举例 | 
| 整数类型 | 不带小数点的数字 | 666 -88 | 
| 小数类型 | 带小数点的数字 | 13.14 -5.21 | 
| 字符串类型 | 用双引号括起来的内容 | “HelloWorld” “霍欣标” | 
| 字符类型 | 用单引号括起来的内,容只能有一个 |  ‘A’ ‘0’ ‘我' | 
| 布尔类型 | 布尔值,表示真假 只有两个值 | true false | 
| 空类型 | 一个特殊的值,空值 | null | 
制表符
在打印的时候,把前面字符串的长度补齐到8,或者8的整数倍。最少补1个空格,最多补8个空格。

变量
变量是指在程序的执行过程中,其值有可能发生改变的量(数据)。当某个数据经常发生改变时,我们也可以用变量存储。当数据变化时,只要修改变量里面记录的值即可。
int 整数 double 小数
package cn.bigengwu.dome1;
public class HelloWorld {
    public static void main(String[] args) {
        // int 整数
        int a = 10;
        System.out.println(a);
        //double 小数
        double b = 10.1;
        b = 10.2;
        System.out.println(b); // 10.2
        // 一行定义多个变量
        int c = 10,d = 20,e = 30, f = 40;
        System.out.println(c); // 10
        System.out.println(d); // 20
        System.out.println(e); // 30
        System.out.println(f); // 40
    }
}数据类型
Java语言的数据类型分为:基本数据类型,引用数据类型。
long变量后的值要跟一个L (建议大写) ,例如:long a = 9999999999999999L;
float 变量后的值要跟一个F(建议大写) ,例如:float a = 10.1F;
| 数据类型 | 关键字 | 取值范围 | 内存占用 | 
| 整数 | byte | -128~127 | 1 | 
short | -32768~32767 | 2 | |
int 默认 | -2147483648~2147483647(10位) | 4 | |
long | -9223372036854775808 ~9223372036854775807(19位) | 8 | |
| 浮点数 | float | -3.401298e-38 到 3.402823e+38 | 4 | 
double 默认 | -4.9000000e-324 到 1.797693e+308 | 8 | |
| 字符 | char | 0-65535 | 2 | 
| 布尔 | boolean | true 和 false | 1 | 
| 字符串 | String | 黑马霍欣标 | 
整数和小数取值范围大小关系:double > float > long > int > short > byte
标识符
标识符就是给类、方法、变量等起的名字。
- 由数字、字母、下划线
_和美元符$组成 - 不能以数字开头
 - 不能是关键字
 - 区分大小写
 
小驼峰命名法(方法、变量):标识符是一个单词,全部小写name;是多个单词,第一个单词首字母小写,其他单词首字母大写firstName
大驼峰命名法(类名):标识符是一个单词,首字母大写Student ;是多个单词,每个单词首字母都大写GoodStudent
键盘录入
Java帮我们写好一个类叫Scanner,这个类就可以接收键盘输入的数字(整数)。
- 导包:找到
scanner这个类,要写在class的前面 - 创建一个
scanner对象, 表示我要使用scanner这个类了 - 接收用户输入的数据
 - 输出数据
 
// 1. 导包
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        // 2. 创建一个scanner对象, 表示我要使用scanner这个类了
        Scanner sc = new Scanner(System.in);
        //3. 接收用户输入的数
        int i = sc.nextInt();
        System.out.println(i);
    }
}运算符
运算符是对字面量或者变量进行操作的符号。
表达式是用运算符把字面量或者变量连接起来,符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。
+ 加- 减* 乘/ 除% (取模、取余)
在代码中,如果有小数参与计算,结果有可能不精确的。
System.out.println(10 % 3); // 1
System.out.println(10 % 2); // 0数值拆分
键盘录入一个三位数,将其拆分为个位、十位、百位后,打印在控制台。
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        // 创建一个键盘录入对象
        Scanner sc = new Scanner(System.in);
        // 提示
        System.out.println("请输入一个三位数");
        // 接收键盘输入的数字
        int number = sc.nextInt();
        // 个位
        int ge = number % 10;
        // 十位
        int shi = number / 10 % 10;
        // 百位
        int bai = number / 100 % 10;
        System.out.println(ge);
        System.out.println(shi);
        System.out.println(bai);
    }
}数字相加
数字进行运算时,数据类型不一样不能运算,需要转成一样的,才能运算。
byte short char 三种类型的数据在运算时,都会直接先提升为int,然后再进行运算
隐式转换:“取值范围小的数值”转换“取值范围大的数值”,小的会先自动提升为大的,再进行运算。
(小)
byte > short > int > long > float > double(大)
强制转换:“取值范围大的数值”转换“取值范围小的数值”,是不允许直接赋值的,一定需要强制转换。
(大)
double > float > long > int > short > byte(小)
public class HelloWorld {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (byte) a;
        System.out.println(b);  // 12强制转换为byte整数类型
    }
}public class HelloWorld {
    public static void main(String[] args) {
        byte a1 = 30;
        byte a2 = 20;
        byte count = (byte) (a1 + a2);
        System.out.println(count); // 50
    }
}字符串相加
当+操作中出现字符串时,这个+是字符串连接符,而不是算术运算符了。会将前后的数据进行拼接,并产生一个新的字符串(从左到右逐个执行)。
public class HelloWorld {
    public static void main(String[] args) {
        byte a = 1;
        int b = 1999;
        String c = "霍欣标";
        System.out.println(a + b + c); // 2000霍欣标
        System.out.println("on" + true); // ontrue
        System.out.println("中" + "nice" + true); // 中nicetrue
        System.out.println(3 + 1 + "个" + 4 + 4); // 4个44
    }
}“字符+字符”和“字符+数字”,会把字符通过ASCII码表查询到对应的数字再进行计算。
public class HelloWorld {
    public static void main(String[] args) {
        char uname = 'a';
        int i = uname +;
        System.out.println(i); // 97 Ascii码里的a对应的数字是97
    }
}
自增自减运算符
++和--既可以放在变量的前边,也可以放在变量的后边,只要单独写一行前面和后面的结果是一样的。
public class HelloWorld {
    public static void main(String[] args) {
        int a = 10;
        a++;
        System.out.println(a); // 11
        ++a;
        System.out.println(a); // 12
        a--;
        System.out.println(a); // 11
    }
}a++ 口诀是先用后加;++a 口诀是先加后用。
public class HelloWorld {
    public static void main(String[] args) {
        int a = 10;
        int a1 = a++;
        System.out.println(a1); // 10
        System.out.println(a); // 11
        int b = 10;
        int b1 = ++a;
        System.out.println(b1); // 11
        System.out.println(b); // 10
    }
}赋值运算符
=   赋值             int a = 10+= 加后赋值      a += 10 等于 a = a + 10-= 减后赋值      a -= 10 等于 a = a - 10=* 乘后赋值      a *= 10 等于 a = a * 10/= 除后赋值      a /= 10 等于 a = a / 10=% 取余后赋值  a %= 10 等于 a = a * 10
public class HelloWorld {
    public static void main(String[] args) {
        int a = 9;
        a += 10;
        System.out.println(a); // 19
        // 等同于
        int b = 9;
        b = b + 10;
        System.out.println(b); // 19
    }
}关系运算符
>左边是否大于右边
<左边是否小于右边
>=左边是否大于或等于右边
<=左边是否小于或等于右边
==左右两边值是否相等比较结果为boolean类型,即只会得到
!==左右两边是否不全等true或false
逻辑运算符
如果判断一个变量 num 是否大于5且小于10,5 < num < 10 ,就用逻辑运算符用来解决多重条件判断。
| 运算符 | 名称 | 说明 | 口诀 | 
|---|---|---|---|
& | 逻辑与(且) | 两边都为真,结果才为真 | 两边都要满足 | 
| | 逻辑或 | 或者,两边都为假,结果才是假(只有一个真则为真) | 两边满足一个 | 
^ | 逻辑异或 | 相同为false,不同为 true | |
! | 逻辑非 | 取反 | 
public class HelloWorld {
    public static void main(String[] args) {
        // 1. &(并且)两边都为真,结果都为真
        System.out.println(true & true); // true
        System.out.println(false & false); // false
        System.out.println(true & false);  // false
        System.out.println(false & true); // false
        // 2. |(或者)两边都为假,结果都为假
        System.out.println(false | false); // false
        System.out.println(true | true);  // true
        System.out.println(true | false); // true
        System.out.println(false | true); // true
        // 3. ^(异或)两边相同为假,两边不同为真
        System.out.println(false ^ true);  // true
        System.out.println(true ^ false);  // true
        System.out.println(false ^ false); // false
        System.out.println(true ^ true);   // false
        // 4. !(非)真变假,假变真
        System.out.println(!true); // false
        System.out.println(!false); // true
    }
}短路逻辑运算符
| 符号 | 作用 | 说明 | 口诀 | 
&& | 短路与 | 结果和&相同,但是有短路效果 | 左为false,右不管是真是假,结果一定是false | 
|| | 短路或 | 结果和|相同,但是有短路效果 | 左为true,右不管是真是假,结果一定是true。 | 
public class HelloWorld {
    public static void main(String[] args) {
        // 1. (&&)运行结果和(&)相同,两边都为true结果才是true,否则为false
        System.out.println(true && true);   // true
        System.out.println(false && false); // false
        System.out.println(true && false);  // false
        System.out.println(false && true);  // false
        // 2. (||)运行结果和(|)相同,两边都为false结果才是false,否则为true
        System.out.println(true || true);   // true
        System.out.println(false || true);  // true
        System.out.println(true || false);  // true
        System.out.println(false || false); // false
        // 3. 逻辑运算符的短路现象
        int a = 10;
        int b = 10;
        // 如果左边为false,右边不执行 (false && false)
        boolean  result = ++a < 5 && ++b < 5;
        System.out.println(result); // false
        System.out.println(a); // 11
        System.out.println(b); // 10
    }
}需求:数字6是一个真正伟大的数字,键盘录入两个整数。如果其中一个为6,最终结果输出true。如果它们的和为6的倍数。最终结果输出true。其他情况都是false。
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number1 = sc.nextInt();
        System.out.println("请输入一个整数");
        int number2 = sc.nextInt();
        // 
        // 如果满足其中一个,那么就可以输出true
        boolean result = number1 == 6 || number2 == 6 || (number1 + number2) == 6 || (number1 - number2) % 6 == 0;
        System.out.println(result);
    }
}三元运算符
需求是定义一个变量记录两个整数的较大值。作用是可以进行判断,根据判断的结果得到不同的内容。
public class HelloWorld {
    public static void main(String[] args) {
        // 三元运算符
        // 格式:条件表达式(?)表达式1(:)表达式2;
        // 流程:首先判断条件表达式的值,如果是true,运算后的结果是表达式1;如果是false,运算后的结果是表达式2;
        int a = 5 > 3 ? 5 : 3;
        int b = 5 < 3 ? 5 : 3;
        System.out.println("a的值是:"+a);
        System.out.println("b的值是:"+b);
        int number1 = 10;
        int number2 = 20;
        int max =  number1 > number2 ? number1 :number2;
        System.out.println("最大值是:"+max);  // 20
    }
}运算符优先级
优先级 运算符
-  
.(){} -  
!~++-- */%+-<<>>>>><<=>>=instanceof==!=&^|&&||?:=+=-=*=/=%=&=
原码反码补码
原码:十进制数据的二进制表现形式,最左边是符号位,0为正,1为负。
一个字节:1个符号位 + 数据(7个比特位bit)
最大值:0 1 1 1 1 1 1 1(127)
最小值:1 1 1 1 1 1 1 1(-127)
利用原码对正数进行计算是不会有问题的。但是如果是负数计算,结果就出错,实际运算的结果,跟我们预期的结果是相反的。
反码:正数的补码反码是其本身,负数的反码是符号位保持不变,其余位取反。
为了解决原码不能计算负数的问题而出现的。
计算规则:正数的反码不变,负数的反码在原码的基础上,符号位不变,数值取反, 0 变 1,1 变 0。
补码:正数的补码是其本身,负数的补码是在其反码的基础上+1

| 运算符 | 含义 | 运算规则 | 示例 | 
| << | 左移 | 向左移动,低位补0 | 200 << 2 800 | 
| >> | 右移 | 向右移动,高位补0或1 | 200 >> 2 50 | 
| >>> | 无符号右移 | 向右移动,高位补0 | 
原创文章,作者:霍欣标,如若转载,请注明出处:https://www.bigengwu.cn/xue/205.html
                
评论列表(1条)
每天坚持练习!