【Java回顾】java语言基础(一)，
【Java回顾】java语言基础(一)，
目录
1.Java平台分类
2.Java开发环境搭建
3.Java的优点
4.数制及其运算
5.数据类型
6.数据类型的转换
7.标识符
8.运算符
9.逻辑语句
10.方法
11.字符串
12.数组
13.参考来源
1.Java平台分类
Java SE(Standard Edition)：java中的一些应用api,可以开发桌面应用，包含了集合类，字符串、io流，jdbc，swing
Java EE(Enterprise Edition): 用于企业web应用的开发，包含了Servlet，Jsp，Filter,Listener
Java ME(Micro Edition)：用于嵌入式系统的开发
Android:java语言 Android平台
2.Java开发环境搭建
JDK(java development kit):Java开发环境
JRE(java run environment):Java的运行环境
3.Java的优点
一处编译处处运行
.java源文件 -> .class字节码文件 -> 运行在jvm(java VMware)上面 -> 运行在操作系统上
不同的操作系统上有不同的jvm版本
4.数制及其运算
数制转换
1、其他数制转换成十进制
规则：利用按权展开式求和。
例：二进制转换成十进制
(1010)2=1*2(3)+1*2(1)=10
八进制转换成十进制
(3167) 8 = 3*8(3)+1*8(2)+6*8(1)+7*8(0)=1655
十六进制转换成十进制
(2B)16= 2*16(1)+11*16(0)=43
2、十进制数转换成二进制数
规则：除以2取余，即对十进制整数逐次除以2，直至商数为0，逆向取每次得到的余数。
如：(215)10= (11010111)2 (59)10=(111011)2
2）小数部分（乘2取整，正向）
规则：乘以2取整，即对十进制的小数部分逐次乘以2，直至乘积的小数部分为0，取每次乘积的整数部分。
如：(0.6875)10=(0.1011)2
(0.1)10=(0.0001100110011)23、二进制数与八进制或十六进制数之间的转换
1）二进制与八进制之间的转换
二进制转换成八进制：以小数点为基准，分别向左、右每三位一组划分，将每三位代以八进制数字（前后端不足三位者用零补齐）。
如：(011 101 010 011)2=(3523)8
八进制转换成二进制：每一个八进制数字代以三个二进制数字
如：(3740)8=(11 111 100 000)22）二进制与十六进制之间的转换
二进制转换成十六进制：以小数点为基准，分别向左、右每四位一组划分，将每四位代以十六进制数字。
如：(1111 0101 0011)2=(F53)16
十六进制转换成二进制：每一个十六进制数字代以四个二进制数字
如：(2AF)16=(10 1010 1111)2
数制运算及存储
[原码]二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
[反码]表示法规定：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
[补码]表示法规定：正数的补码与其原码相同；负数的补码是在其反码的末位加1。
引入原码 反码 和补码的目的就是为了解决减法问题,因为计算机CPU的运算器中只有加法器,要把减法转化成加法来计算.
举个例子,A表示十进制数“+16”,B表示十进制数“-19”,把这两个数的原码直接相加,得：
A＝＋16 （A）原＝00010000
B＝－19 （B）原＝10010011
00010000
+10010011
————
10100011
其结果符号位为1是负数,其数值位为100011,即等于十进制数“-35”,这显然是错的结果.
再比如,十进制数“+16”与“+19”的原码直接相减,得：
00010000
- 00010011
————
11111101
结果为“-125”,这又是错的.
但是引入补码后,加减法都可以用加法来实现,如“-16+11”的运算：
11110000 -16的补码+00001011 11的补码
————
11111011 -5的补码如果是“-16-11”,那么就转化为加法运算“-16+（-11）”
11110000 -16的补码+ 11110101 -11的补码
————
111100101 -27的补码在字长为8位的系统中,最高位所产生的进位被自然丢弃,运算结果的机器数为11100101,是-27的补码形式,结果正确.通过补码运算，可以把减法运算变成加法运算；而乘法可以用加法来做，除法可以转变成减法。这样一来，加、减、乘、除四种运算“九九归一”了。这对简化CPU的设计非常有意义，CPU里面只要有一个加法器就可以做算术运算了。
Byte类型的取值范围是-128～127的理解（补码表示）
0 00000000
1 00000001
…….
127 01111111
----------------
正数（包括0）共 128 个 (需获得原码)
-1 11111111
-2 11111110
……
-128 10000000
----------------
负数共 128 个
我们都知道byte占8位。而等于256，也就是byte最多可以表示256个不同的数，
0~127：128个
-0~127：128个
但是这里0与-0表示一样的数了，所以就用-0的二进制补码表示到-128里面去了（这里是关键，也就是说-0的补码用来表示-128了，-0的补码"10000000"通过逆向计算刚好得到-128这个值）
5.数据类型
a.基本数据类型 8种（n位范围：-~-1，Bit意为"位"或"比特，Byte意为"字节"，1byte=8bits）
数字类型：
整形：
byte(8位 初始值：0)[基本类型]->Byte(初始值：null)[包装类型] -128(-)~127(-1)
short(16位 0)->Short(null) -~-1
int(32位 0)->Integer(null)
long(64位 0)->Long(null)
浮点形：
float(32位 0.0)->Float(null)
double(64位 0.0)->Double(null)
字符类型：
char(16位 \u0000)->Character(null) unicode编码 \u0000~\uffff
boolean类型:
boolean(1位 true or false 默认false)->Boolean(null)
b.引用(对象)类型
数组、类、接口、String(java中的特殊类)
//1.浮点型运算时需要保留精度需借用BigDecimal类完成
double a = 0.1;
double b = 0.2;
System.out.println(a+b);//0.30000000000000004,精度有问题
BigDecimal b1 = new BigDecimal(String.valueOf(a));
BigDecimal b2 = new BigDecimal(String.valueOf(b));
b1 = b1.add(b2);//加运算
System.out.println(b1.doubleValue());//0.3
//2.基本数据类型(存值本身)和包装类(存地址)
int a = 100;
Integer b = new Integer(100);//指向堆内存
System.out.println(a == b);//true，==比的是地址，拿基本数据类型和包装类型比较时，会自动解包的，比的是值了
//Double c = 100.0;
Integer c = new Integer(100);
Integer d = 100;//指向常量池
System.out.println(c == a);//true
System.out.println(b == c);//false
6.数据类型的转换
数据类型转换的前提:数据类型要兼容
自动转换(向上转型) :小类型转大类型
byte->short->int->long->float->double
char->int->long->float->double
强制转换(向下转型) :大类型转小类型
//3.类型转换
byte a = 7;
char b = (char) a;
System.out.println(b);//响铃，eclipse无法显示
char c = '你';
int i = c;
System.out.println(Integer.toBinaryString(i));//0100 1111 0110 0000
System.out.println(Integer.toOctalString(i));//47540
System.out.println(Integer.toHexString(i));//4f60
c = '\u4f60';
System.out.println(c);//你，将char直接转化为int，其值就是字符的ascii
// 128 int类型 -> 24个0 1000 0000
byte d = (byte) 128;//强制转换类型，数据精度丢失，剩下1000 0000
System.out.println(d); // -128
7.标识符
类:首字母大写
属性:首字母小写
方法名称:首字母小写
变量名:小写
常量全部大写
由数字 字母 _ $组成，不能以数字开头 长度没有限制 严格区分大小写
不能使用关键字或者保留字作为标识符
关键字列表 (依字母排序 共50组)：
abstract, assert, boolean, break, byte, case, catch, char, class, const（保留关键字）, continue, default, do, double, else, enum, extends, final, finally, float, for, goto（保留关键字）, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while
保留字列表 (依字母排序 共14组)，Java保留字是指现有Java版本尚未使用，但以后版本可能会作为关键字使用：
byValue, cast, false, future, generic, inner, operator, outer, rest, true, var, goto （保留关键字） , const （保留关键字） , null
8.运算符
数学运算： + - * / % ++ --
boolean逻辑运算符： & | ! &&短路功能 ||短路功能 ^异或
关系运算符: > < >= <= != ==
赋值运算符: = += -= *= /= %=
位运算符:& | ^ ~ >> >>> <<
三目运算符 boolean表达式?值1:值2
运算符优先级表(从上到下，优先级逐级递减)
优先级
运算符
结合性
1
() [] .
从左到右
2
! +(正) -(负) ~ ++ --
从右向左
3
* / %
从左向右
4
+(加) -(减)
从左向右
5
<< >> >>>(移位运算符)
从左向右
6
< <= > >= instanceof(比较运算符)
从左向右
7
== !=
从左向右
8
&(按位与)
从左向右
9
^(异或)
从左向右
10
|(按位或)
从左向右
11
&&(逻辑与)
从左向右
12
||(逻辑或)
从左向右
13
?:(三目运算符)
从右向左
14
= += -= *= /= %= &= |= ^= ~= <<= >>= >>>=
从右向左
助记口诀
单目乘除为关系，逻辑三目后赋值。
单目：单目运算符+ –(负数) ++ -- 等
乘除：算数单目运算符* / % + -
为：位移单目运算符<< >>
关系：关系单目运算符> < >= <= == !=
逻辑：逻辑单目运算符&& || & | ^
三目：三目单目运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：赋值=
//4.数学运算符
int i = 1;
System.out.println(++i);//2,先运算 再使用值
System.out.println(i++);//2,先使用值再运算
System.out.println(i);//3
//5.boolean逻辑运算符
int a = 1;
int b = 2;
int c = 3;
int d = 4;
boolean b1 = ++a == b++ || c++ <= ++d;//||短路功能
System.out.println(a);//2
System.out.println(b);//3
System.out.println(c);//3
System.out.println(d);//4
System.out.println(b1);//true
//6.赋值运算符
byte b = 5;
//b = b + 1;//+运算会将结果转换为int类型,除非强制转换,否则出现编译期异常
b = (byte) (b + 1);//b为int类型
b += 1;//7,一步操作,赋值运算符,b为byte类型
int a = 10;
a += a *= a -= 1;
System.out.println(a); //100,从右往左运算,10+10*(10-1)
//7.位运算符，计算机存的数为补码
byte i = 1;// 0000 - 0001
byte j = ~1;// 1111 - 1110
System.out.println(j);
System.out.println(i & j);//0000 - 0000
System.out.println(i | j);//1111 - 1111
System.out.println(i ^ j);//1111 - 1111
System.out.println("左移:"+ (i<<31));//低位补0 左移n位 原来的值扩大2^n倍(正数时候)
i = -1;// 1111 1111
System.out.println("右移:"+ (i>>8));//正数 高位补0 负数高位补1
System.out.println("右移:"+ (i>>>1));//无符号右移 高位补0
9.逻辑语句
分支语句
a. if(boolean表达式){
语句;
}[
else if(boolean表达式){
语句;
} else{
语句;
}]
b.switch分支
switch(变量名){
case 值1:
值3:
语句;break;
case 值2:语句;break;
....
}
注：做为switch分支的变量的数据类型:byte/short/char/int/String(jdk1.7)/枚举
//8.switch枚举变量
Single.java
public enum Single {
RED,GREEN,YELLO
}
Test.java
Single s = Single.RED;
switch (s) {
case RED:
System.out.println("红灯停");
break;
case GREEN:
System.out.println("绿灯行");
default:
System.out.println("黄灯请缓行");
break;
}
//结果：红灯停
循环语句
for循环
for(初始化表达式;判断表达式;递增（递减）表达式){
执行语句;
}while循环
while(循环条件){
循环体;
}do while循环：至少执行一次循环体
do{
循环体;
}while(循环条件);foreach循环：遍历数组或者集合时用的
for（类型 临时变量名：列表或数组）{
循环体;
}
break 结束当前循环 只能结束一层循环 要跳出多层循环的话 需要添加标签continue 跳出本次循环，接着执行下一次循环
//9.标签跳出循环
ok:
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println("i=" + i + ",j=" + j);
/*
结果
i=0,j=0
i=0,j=1
i=0,j=2
i=0,j=3
i=0,j=4
*/
if (j == 5)
break ok;
}
}
//10.循环条件控制跳出循环；让外层的循环条件表达式的结果可以受到里层循环体代码的控制。
//1、计算1-100内的所有素数(只能被1和他本身整除的数；即去掉偶数，因为其被2整除；除以开方，因为没有必要每个数都除一遍，计算量太大)
for (int i = 1; i <= 100; i += 2) {
boolean flag = false;
for (int j = 2; j <= Math.sqrt(i); j++) {
if (i % j == 0) {
flag = true;
break;
}
}
if (!flag) {
System.out.println(i + "是一个素数");
}
}
//2、在二维数组中查找到某个数字。
int arr[][] = { { 1, 2, 3 }, { 4, 5, 6, 7 }, { 9 } };
boolean flag = false;
for (int i = 0; i < arr.length && !flag; i++) {
for (int j = 0; j < arr[i].length; j++) {
if (arr[i][j] == 5) {
System.out.println("i=" + i + ",j=" + j);//结果：i=1,j=1
flag = true;
break;
}
}
}
10.方法
a.概念：定义一段可以重复使用的代码
b.结构：[权限修饰符] [其他修饰符] 返回值类型(void或者具体的数据类型) 方法名称([[final] 形式参数数据类型 参数名字,....])
其他修饰符：static,final,synchronized,native等 native声明的方法是本地方法 没有方法体
权限修饰符:public -> protected -> 缺省 -> private
c.方法的调用:方法的名称([实际的参数,...])
d.重载(Overload)：在同一个类中，方法的名称相同，参数不同(参数类型,个数,顺序不同)构成方法的重载
e.构造方法:创建对象时调用的方法
f.构造方法的结构:[权限修饰符] 类名([[参数类型 参数名字],....]){}
g.构造方法的调用:在创建对象时(new/反射/反序列化/克隆创建) 调用的,只要有对象创建，构造方法肯定会被调用
每个类默认都会有一个无参数的构造方法，除非自定义了构造方法
如果显示定义了带参数的构造方法，系统则不再创建无参数的构造方法了，需要显式定义无参数的构造方法，
构造方法是可以重载的
访问修饰符
作用范围 所在类 同一包内其他类 其他包内子类 其他包内非子类 private 可以访问 不可以 不可以 不可以 缺省 可以 可以 不可以 不可以 protected 可以 可以 可以 不可以 public 可以 可以 可以 可以
其他修饰符（部分）
final：含义为最终的，最后的。顾名思义，被 final 修饰后则不能再进行修改。
修饰对象 效果 类 被 final 修饰的类不能被继承 方法 被 final 修饰的方法不能被重写 变量 被 final 修饰的变量不能被更改（若是变量的基本类型、值不能改变；如果为引用类型，引用不能改变，值可变） 区别： final修饰一个对象时，表示对象的引用不能变，内容可以改变的 finally 修饰的是代码块 finalize()：Object类中的方法,该方法是在jvm回收对象垃圾时调用的
static：含义为静态的。被 static 修饰后则代表已经不再属于某个对象，而是属于类。
修饰对象 效果 内部类 static 修饰的内部类时，可以直接通过“类名.内部类名”的方式来调用，不用先创建外部类的对象 构造代码块 static 修饰构造代码块时，该构造块属于类，构造块内部的代码仅会执行一次 方法 static 修饰方法时，该方法属于类，可以直接通过“类名.方法名”来调用，不需要创建类的对象 变量 static 修饰变量时，该变量属于类，可以直接通过“类名.变量名”来调用，不需要创建类的对象 native
"A native method is a Java method whose implementation is provided by non-java code."
简单来说一个Native Method就是一个java调用非java代码的接口。
这个也比较好理解，因为java底层本来就是用c、c++去写的，所以当然有对应接口去直接调用C/C++写的方法；而且众所周知java对底层的操作远不如C/C++灵活，所以可以通过直接调用非java代码来实现对底层的操作。在java api中有很多这种方法，例如：
系统提供的数组拷贝方法public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);等
11.字符串
a.效率从低到高:String -> StringBuffer（String缓冲器） -> StringBuilder（String生成器）
b.String的equals和==
==比的是地址
equals比较的是字符串的内容是否相同
String、StringBuilder、StringBuffer、CharSequence
关系
首先，CharSequence是一个接口，用于表示有序的字符集合，并提供了一些基本的操作方法。
String StringBuffer StringBuilder都实现了CharSequence这个接口。
关系图如下：
区别
我们了解了他们的关系之后，我们再了解一下他们的区别：
名称 说明 CharSequence 接口，表示有序的字符集合 String 常量，长度不可变,String类的常用方法详见:https://blog.csdn.net/Y1013768371/article/details/89041191 StringBuffer 可变长度字符序列，线程安全 StringBuilder 可变长度字符序列，非线程安全 注：
1.如果要操作少量的数据用： String
2.单线程操作字符串缓冲区 下操作大量数据 ：StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 ： StringBuffer
//11.引用类型的转换
String s1 = new String("abc");
CharSequence s2 = s1;//转型 s2中存的是String类型
System.out.println(s2); //abc为String类型
StringBuffer s3 = new StringBuffer("abc");
s2 = s3;//转型 s2中存的是StringBuffer类型
//s1 = (String) s2;//String与StringBuffer不兼容，必须通过toString方法转换，否则抛出ClassCastException
s1 = s2.toString();
s3 = (StringBuffer) s2;
System.out.println(s1); //abc为String类型
System.out.println(s3); //abc为StringBuffer类型
//12.关于String是不可变的
String s1 = "a" + "b" + "c";
//就等价于String s1 = "abc";
String a = "a";
String b = "b";
String c = "c";
String s2 = a + b + c;
//这个就不一样了，引用类型和字符串拼接时使用StringBuilder操作的,堆中有创建对象，最终结果相当于：
StringBuffer temp = new StringBuffer();
temp.append(a).append(b).append(c);
String s2 = temp.toString();
System.out.println(s1 == s2);//false
12.数组
//13.数组
Test.java
public static void main(String[] args) throws CloneNotSupportedException {
// 1.数组声明 数据类型[] 引用名 or 数据类型 引用名[]
int[] arr;
Dog dogs[];
// 2.数组的初始化
// 2.1 new 数据类型[长度] 先分配空间 并且把数组中的值初始化为该类型的默认值
arr = new int[5];
dogs = new Dog[3];
// 根据下标赋值
arr[0] = 1;
dogs[0] = new Dog();
// 使用对象数组中的方法 要注意数组中对象的初始化
System.out.println(dogs[0].getName());
// 2.new 数据类型[]{值1,值2,....} 分配空间 并且对内容初始化
arr = new int[] { 1, 2, 3, 4, 5 };
// 3.静态赋值 声明数组时 直接赋值
Dog[] dogs2 = { new Dog() };// 静态初始化
// 4.二维数组：数组的数组
// 声明
// a.数据类型[][] 变量
// a.数据类型[] 变量[]
// a.数据类型 变量[][]
int[][] arr2;
int[] arr3[];
int arr4[][];
arr2 = new int[3][];// 只指定二维数组的数组的长度(行)
arr3 = new int[2][3];// 都指定了
arr2[0] = new int[] { 0, 1, 2 };
arr2[1] = new int[] { 3, 4 };
arr2[2] = new int[] { 5 };
System.out.println(arr2[0][0]);
// 遍历二维数组
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[i].length; j++) {
System.out.println("arr2[" + i + "][" + j + "]=" + arr2[i][j]);
}
}
// 数组的引用传递
int[] abc = new int[] { 1, 2, 3, 4, 5 };
change(abc);
System.out.println(abc[0]);
// 可变参数
Dog dog = new Dog();
dog.eat(2, "鱼", "肉");
dog.eat(1, new String[] { "狗粮"});
}
public static void change(final int[] arr) {
// arr = new int[]{1,3,6};
arr[0] = 100;
}
Dog.java
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 可变参数的定义 数据类型...
* 可变参数必须写在参数列表的最后一位
*/
public void eat(int age,String... foods){
System.out.println("这只狗今天吃了什么呢？");
for(int i=0;i<foods.length;i++){
System.out.println(foods[i]);
}
}
/*输出：
null
0
arr2[0][0]=0
arr2[0][1]=1
arr2[0][2]=2
arr2[1][0]=3
arr2[1][1]=4
arr2[2][0]=5
100
这只狗今天吃了什么呢？
鱼
肉
这只狗今天吃了什么呢？
狗粮
*/
13.参考来源
相关文章
- 暂无相关文章
用户点评