java基础部分总结

最新推荐文章于 2022-07-26 19:27:04 发布

我觉得妥了

最新推荐文章于 2022-07-26 19:27:04 发布

阅读量204

点赞数 1

分类专栏： JavaSE基础文章标签： javaSE 基础总结

本文链接：https://blog.csdn.net/weixin_45052984/article/details/103341436

版权

JavaSE基础专栏收录该内容

0 篇文章 0 订阅

订阅专栏

java基础部分总结

javaSE阶段基础复习-由易-->难
- 从HelloWorld开始

javaSE阶段基础复习-由易–>难

你好！这是我写的第一篇博客，今天这篇文章主要写javaSE基础部分的总结，是对自己学习的一个总结，也希望对你们有所帮助，如果有什么不足的也希望大家指出，秉着共同学习共同进步的精神。

从HelloWorld开始

public class HelloWorld {
    public static void main(String[] args){
    System.out.println("Hello World!");
    }
}

java编程规范（规范不是语法，如果违背可能会导致未知问题）

类名要求所有单词的首字母都要大写。例：UserName
方法名和变量名要求首字母小写，其它单词的首字母大写。例：userName
包名所有字母全小写，不同单词用点 . 隔开。例：user.name
常量名所有字母全大写，不同单词用下划线 _ 隔开。例：USER_NAME
不同的部分之间用空行隔开。
不同层级之间有缩进。缩进最好是2个或者4个空格。
不要用中文，虽然语法上可以。英文最好望文知意。

几个常见术语

JDK – Java开发工具包，是官方提供下载安装的Java开发工具。
JRE – Java运行环境，Java开发必须要先有 JRE 。
JVM – Java虚拟机，所有的Java程序都必须运行于 JVM中。
IDE – 集成开发环境，就是Java开发工具，主要指： Eclipse和IDEA
API – 应用程序接口，就是官方提供的文档，或者说 Java的开发说明书。

java的几个问题：

java如何管理内存
Java语言用 new 分配内存，会在堆中创建一个对象。 Java的内存回收由 JVM 完成，程序员无需进行内存的回收。JVM通过一个守护线程进行内存垃圾的回收，没有引用指向的对象就是内存垃圾。程序员可以建议 JVM 回收内存垃圾，通过System.gc()或者Runtime.gc()，但决定权在 JVM 。
Java如何实现跨平台？
Java在安装时，针对不同的操作系统会下载不同的安装包。然后在编译时，生成的class文件(字节码文件)是一样的。不同的安装包会把 class文件解释成不同的操作系统能识别的机器指令，从而实现胯平台。
Java的主要用于哪些方面的开发，对于哪些版本？
JavaSE 所有Java开发的基础，还可以用于 PC桌面版的开发。
JavaEE 企业级开发，目前是Java开发主战场。
JavaME 微缩版，主要用于手机、家电的开发，目前手机和PAD被安卓系统取代。

变量

变量 ——》一块内存，内存以变量的形式去操作。程序运行必须的硬件是：CPU(运算)和内存(存取数据)。程序员通过定义和使用变量的方式去操作内存中的数据。
Java是强类型的编程语言，为什么说java是强类型语言，就是变量在使用之前，必须先声明其类型。
变量的定义方式：
变量类型变量名 = 值 ; 或变量类型变量名；
其中，（ = 值）可以出现，也可以不出现；但没有赋值的变量不一定能使用(局部变量一定不能使用)。
例如：int age = 25 ; //声明的同时赋值
int age ; //先声明后赋值
age = 25;
讲到这里引入一下java的数据类型

JAVA的数据类型:

主要分为基本数据类型和引用数据类型
基本类型包括8种：
整型：byte 、short 、int 、long（通俗来说就是整数）
浮点型：float 、double（通俗来说就是小数）
字符型：char（通俗来说就是单个文本）
布尔型：boolean （表示逻辑是或否）
引用类型包括5类：类、接口、数组、枚举、标注(注解)。
我们最常用的String 是引用数据类型，它是属于类，（翻看源码可以知道这是一个用final修饰的最终类）
float double 都是近似值，不是精确值。（例如）

System.out.println(0.2+0.1==0.3);//结果为false
System.out.println(0.2+0.1);//结果为0.30000000000000004

byte short int long 都是有表述范围的；
byte – 负的2的7次方到正的2的7次方减1
short – 负的2的15次方到正的2的15次方减1
int – 负的2的31次方到正的2的31次方减1 (大概在正负21亿之间)
long – 负的2的63次方到正的2的63次方减1

内存/文件的存储单位：
位 bit – 每一个0或者1 叫一个二进制位，是最小的存储单位。
字节 byte – 8个二进制位叫一个字节，内存/文件的基本存储单位。
千字节 KB – 1024个字节叫一个 KB
兆字节 MB – 1024个KB 叫一个 MB
吉字节 GB – 1024个MB 叫一个 GB

变量的声明和初始化:

变量的声明 – 变量在第一次出现时，必须带着类型一起，叫变量的声明。
变量的初始化 – 变量的第一次赋值叫变量的初始化。
变量的输入和输出：
变量的输出 ： System.out.println()

变量的输入 ： System.in + IO流或者 Scanner
变量的输入步骤：
1、先要导入 Scanner --> import java.util.Scanner;
2、定义一个Scanner类型的变量， Scanner sc = new Scanner(System.in);
3、 sc.next() – 从键盘读一个文本(String)
sc.nextInt() – 从键盘读一个整数(int)
sc.nextDouble() – 从键盘读一个小数(double)
…还有一些就不一一介绍了

Java中，默认的整数为int；默认的小数为 double 。
5L --> long 整数后加L 表示long（这里不加不会报错，但是要养成好的习惯）
5.0F --> float 小数后加F 表示float数据类型（不加会报错）

进制转换

整数在 Java中有四种进制，默认的10进制，底层的2进制，以及 8进制和 16进制。
二进制就是逢2 进位，数字只有 0 和 1 。
十六进制就是逢 16进位，0 到 9 A 到 F 。
八进制和十六进制都是二进制的缩写，4位二进制简写为十六进制。
十进制和二进制的转换：
二进制数的第一位叫符号位，非负数为0，负数为1。
正数和零 的二进制转十进制：
把所有的1的权重加起来就可以了。(验算的话可以用电脑自带的计算器选择程序员)
例如： 0101 1101 -> 1 + 4 + 8 + 16 + 64 = 93
0111 0011 -> 1 + 2 + 16 + 32 + 64 = 115
正数和零的十进制转二进制：

把十进制的数字依次除以2，然后记录余数，直到为零。然后把所有的余数反向输出。

结果：	105	52	26	13	6	3	1	0
除以2	105/2 =52	52/2=26	26/2=13	13/2=6	6/2=3	3/2=1	1/2=0	0/2=0
余数	1	0	0	1	0	1	1	0

反向输出： 0110 1001

筛权重，减去能减的最大的权重，然后把这些权重对应的位数为1，其它补0。（个人觉得这个方法速度快一点）
例如：105 - 64 = 41 - 32 = 9 -8 = 1
结果为：0110 1001

负数的二进制转十进制
原则：按位取反再加1。(补码) 得到对应的正数，再添上负号。
1101 0011 -> 0010 1100 + 1 -> 0010 1101 = 45 -> -45
负数的十进制转二进制
    先按照对应的正数进行转换，然后按原则：按位取反再加1（与先减一再按位取反结果一致）。
例： -99
0110 0011 -> 1001 1101
    Java中，整数默认是 10 进制，八进制需要在前面加 0（数字零），十六进制需要在前面加 0X .
11 = 11
011 = 9
0x11 = 17
最大的int的值 = 0111…1111 = 0x7FFF FFFF
最小的int的值 = 1000…0000 = 0x8000 0000
关于字符 char
    Java用Unicode编码表示字符。
char 有两种身份，作为字符和作为整数(编码)。
‘A’ 65 0x41(十六进制，下同)
‘a’ 97 0x61
‘0’ 48 0x30
基本类型的 类型转换

	short a = 10;
	a= a-1;//这行会报错

原因是：a-2表达式已经被提升到int类型，而把int类型的值赋给short，会引发错误。
类型转换就是把一种类型转换成另外一种类型的操作。
类型转换分为 自动类型转换和强制类型转换。
自动类型转换就是 JVM 自动完成的类型转换；强制类型转换就是程序员通过代码指定完成的类型转换
自动类型转换的情况：

常数(在范围内的)可以发生自动类型转换。
表述范围小的可以自动转换成表述范围大的。(不会有精度损失问题)

强制类型转换的情况：
表述范围大的强制转换成表述范围小的。(有可能损失精度)
强制类型转换的语法：
(目标类型) 目标变量
例如：byte b = (byte)200;
基本类型的表述范围：
byte -> char和short -> int -> long -> float -> double
boolean 类型只能是 true或者false，不参与类型转换。

运算符

算数运算符 ：+ – * / % (取余数）
整数相除，只有整数部分，没有小数部分，有余数。
0不能做除数，但 0.0 可以，结果为无穷（0.0是近似值，表示无限接近0）。
浮点和整数混合运算时，先转浮点再运算。
例如：5.4%2 = 1.4
5.4/2 = 2.7
关系运算符 ：> < >= <= == !=
注意：判断是否相等用 == ，一个 = 叫赋值。
关系运算符的结果就是布尔类型，为 true 或者 false .
自增和自减运算符
自增和自减运算符只能用于变量，效果是变量自增1或者自减1。用法完全一样。
自增运算符有两种形式，前置加加(++i) 和后置加加(i++)，区别在于：
++i 取自增后的数做结果，i会自增1 。
i++ 取自增前的数做结果，i会自增1
例如：

int i  = 1;
int x = ++i + i++ + ++i;//x= 2 + 2 + 4; 结果为8

逻辑运算符
逻辑与 & && 用于两个条件，代表并且关系
逻辑或 | || 用于两个条件，代表或者关系
逻辑非 ! 用于一个条件，代表相反
&和&&的区别：
& 既是逻辑与，也是位与运算符；&& 只是逻辑与。
&& 做了优化，当前面的条件决定了整个条件的结果时，后面的条件不再判断，叫短路与。

简单来说，就是如果前面的条件为假时，&& 不再判断后面的条件；
如果前面的条件为真时， || 不再判断后面的条件(后面的条件代码不执行)。
逻辑运算符主要用于 if和循环。
赋值运算符
就是 = ，把右边的值/表达式赋给左边的变量; 是右结合的，从右向左运算。
赋值运算符还可以和其它运算符组合在一起，形成复合赋值。比如： a+=b 效果上等价于 a=a+b 。
那么 += 和 = + 是完全一样的么？
不完全一样， += 是赋值语句， = + 是先加法，在赋值。
例如：

		byte b = 2;
		b+=2;
//		b=b+2;//这行会报错，编译不通过

三目（元）运算符(条件运算符)
语法：
(条件)?结果1:结果2
如果条件为真，取结果1；否则取结果2 。
(a>b) ? a : b 取a和b的最大值。
特性：
(3>4) ? 3.0 : 4 输出？自动转成double，输出 4.0
引文三元运算符会把冒号两边的转换成统一的数据类型
运算符的优先级：
说不准的用括号(),括号的优先级很高。
赋值= 的优先级很低，右边随便写，且是从右向左运算。
位运算符 – 位运算符是针对二进制的。
位运算符包括两类：
移位运算符位与、位或、位反
移位运算符： >>右移 << 左移 >>> 无符号右移
0110 1101
左移1位就是前面丢掉一位，后面补一个0 。
右移1位就是后面丢掉一位，前面补符号位。
无符号右移1位就是后面丢掉一位，前面补0。(不常用)

 7 >> 2 = ?   //0000 0111 ->  0000 0001     1
 7 << 2 = ?   //0000 0111 ->  0001 1100    28 

 右移一位相当于除以2，左移一位相当于乘以2；因此，可以用 移位 取代 2的n次方的乘除法。

 7 >> 34  = 1   超过32/64的移位，先对 32/64取余，然后拿余数去移位。

位与、位或、位反 
 算法就是把数字转成二进制，然后按二进制位进行运算。

程序的三种基本结构

1、顺序结构代码从上到下，一行一行的顺序执行；默认结构
2、选择结构代码按照一定的条件，选择一个分支或者一个分支都不选执行。
3、循环结构代码按照一定的条件，多次反复执行(也可能一次都不执行)。
流程控制语句，包括选择结构和循环结构。
选择结构： if/else switch/case (分支语句)
循环结构： for while do/while
if语句语法：
if(条件1){ //如果一个分支语句只能有一个if
//满足条件1时执行的语句块;
}
else if(条件2){ //或者出现 0 - N 次
//满足条件2时执行的语句块;
}
else{ //否则出现 0次或者1次
//以上所有条件都不满足时执行的语句块;
}

    int a = 10;
    if(a>0){
        System.out.println("正数");
    }else if(a<0){
        System.out.println("负数");
    }else{
        System.out.println("零");
    }

for循环 – 反复执行相同的代码时，使用循环。
for循环的语法：
for( 循环变量的声明和初始化 ; 循环条件 ; 步进语句 ){
//需要反复执行的代码块 ; 循环体
}
打印1-10

 for( int i=1 ; i<11 ; i++ ){
     System.out.println(i);
 }

执行步骤：
   1、int i=1 ，循环变量的声明和初始化 (只执行一次)
   2、判断i<11 ， 如果成立继续执行，否则循环到此为止。
   3、System.out.println(i); 循环体
   4、i++   步进语句
   5、执行步骤2 ， 3 ，4 ， .... 2

次数不确定的循环
for( ; ; ){
…;
if(条件) break;
…;
}
执行步骤：
1、反复执行循环体，直到 if的退出条件满足为止。
退出无限循环(死循环)在dos中用 Ctrl + c 。

Java随机数的API
java.util.Random
步骤:
1、import java.util.Random;
2、Random ran = new Random();
3、ran.nextInt(10); 代表取0到9的随机数

import java.util.Random;

   public class TestRandom{
      public static void main(String[] args){
        Random ran = new Random();
        int x = ran.nextInt(10);//随机0-9的整数
        System.out.println(x);
      }
  }