java基础

Lucky me.

已于 2022-11-03 14:38:16 修改

阅读量117

点赞数

分类专栏： Java 文章标签： java

于 2021-10-17 15:13:15 首次发布

本文链接：https://blog.csdn.net/qq_46025779/article/details/120811238

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Java简述

JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。
JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。
JVM：Java Virtual Machine，java虚拟机，用于保证java的跨平台的特性（java语言是跨平台，JVM不是跨平台的）。

配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

win10 配置Java环境变量例子

1、打开我的电脑 -> 属性 -> 高级系统设置 -> 高级 -> 环境变量 -> 系统变量
2、添加系统变量 JAVA_HOME

变量名：JAVA_HOME
变量值：C:\Program Files\Java\jdk1.8.0_201

3、添加系统变量 CLASSPATH

.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

4、在系统变量 PATH 中，添加环境变量

%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin

5、打开 cmd 命令提示符，验证 java 环境是否安装成功

javac / java -version

注意：在定义classpath环境变量时，如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；如果指定了classpath，那么会在指定的目录下查找要运行的类文件。

基本数据类型：

整数类型：
- byte：字节占据一个byte，值域是-128-127
- short：短整型占用2个byte，值域是-32768-32767
- int：整型占用4个byte，值域是-2147483648-2147483647 java的证书缺省值是int类
- long：长整型占用8个byte，值域是-9223372036854774808-9223372036854774807
浮点（小数）类型：
- float：浮点型（小数）占用4个byte，有精度值域复杂±34028234663852885981170418348451
- double：双精度小数，精度是float的两倍，占用8个byte,java中的浮点数的缺省是double类型
布尔和字符数据类型：
- boolean ：布尔值值域为true 和flase;
- char：字符类型，值域是所有字符

数据转换： 从高类型转底类型(又叫强制转换)会损失精度，排序为：byte < short < int < long < float < double

例子:

byte bytevar=127;

short shortvar=-30000;

int intvar;

long longVar=99L;

float floatVar=33.1F;

double doubleVar=100.1;

boolean condition=true;

char charVar=“a”;

变量：

变量的命名必须是合法的标识符，标识符是由任意的字母、数字、下划线、美元符号和数字组成，并且第一个字符不能是数字，标识符也不能是Java中的保留关键字。

变量又分为：

成员变量（全局变量）：使用的时候要创建类的实例再用类的实例引用该变量
局部变量：也就是方法体内的变量，只在方法体内生效
静态变量：可以直接通过类名访问该变量，不用创建实例

运算符：

1、算术运算符

+、-、*、/、%、++、--

2、赋值运算符

=、+=、-=、*=、/=、%=

3、比较运算符

<、>、=、<=、>=、==、!=

4、逻辑运算符

&&、&、||、！

5、位运算符

&、|、^、~

6、条件运算符（三元运算符）

布尔表达式 ？ 表达式1 ：表达式2

7、移位操作

<<、>>、>>>

例子：
10<<2 等同于 10乘以2的2次方 104=40
20<<4 等同于 20乘以2的4次方 2016=320

10>>2 等同于 10除以2的2次方 10/4=2
20>>4 等同于 20除以2的4次方 20/16=1

注意：

1、算数运算符中，0不能作为除数。
2、在逻辑运算符中，&&和&的区别是：&&具有短路功能，&没有。
3、异或运算（^）规则：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。
4、按位与运算（&）规则：两个数都转为二进制，然后从高位开始比较，如果两个数都为1则为1，否则为 
   0。
5、按位或运算（|）规则：两个数都转为二进制，然后从高位开始比较，两个数只要有一个为1则为1，否 
   则就为0。
6、按位异或（^）规则：两个数都转为二进制，然后从高位开始比较，两个数同时为0或1时，结果为0，否 
   则为1。
7、位非（按位取反）运算（~）规则：如果位为0，结果是1，如果位为1，结果是0。
   在Java中，所有数据的表示方法都是以补码的形式表示，如果没有特殊说明，Java中的数据类型默认            
   是int，int数据类型的长度是8位，一位是四个字节，就是32字节，32bit.
 
   例：37转为二进制是100101，补码后为：00000000 00000000 00000000 00100101
      取反为：11111111 11111111 11111111 11011010
      因为高位是1，所以原码为负数，负数的补码是其绝对值的原码取反，末尾再加1。
      因此，我们可将这个二进制数的补码进行还原：首先，末尾减1得反码：11111111 11111111     
      11111111 11011001 其次，将各位取反得原码：00000000 00000000 00000000 00100110，
      此时二进制转原码为38。
      所以~37 = -38. 
 
8、左移（<<）：就是将运算符左边的操作数的二进制数据按照运算符右边操作数指定的位数向左移动，右 
   面移空的部位补0。一个数左移n，相当于这个数乘以2的n次方。
9、右移（>>）: 就是将运算符左边的操作数的二进制数据按照运算符右边操作数指定的位数向右移动，如 
   果高位是0，左侧被移空的高位就填入0，如果高位是1，左侧被移空的高位就填1.
    
    例：101100 >> 1 = 110110
       001101 >> 1 = 000110
 
10、无符号右移（>>>）：无论高位是0还是1，左侧被移空的高位都填入0。

三元运算

/**变量3=（变量1<变量2）？变量1：变量2
解析：
	等同于
**/
	int c=0;
	if（a>b）{
		c=a;
	}else{
		c=b;
	}

//三元运算
c=(a>b)?a:b

常用运算符：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wYRuoZvu-1634454690308)(C:%5CUsers%5C%E9%99%88%E5%AD%90%E6%B6%B5%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20210907161628196.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AsQ6tJtd-1634454690310)(C:%5CUsers%5C%E9%99%88%E5%AD%90%E6%B6%B5%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20210907164147528.png)]

关键字

abstract ：抽象类，修饰类和方法，修饰类：该类不能被实例化，修饰方法该类不用有方法体，但必须要被子类实现
class ：类，作为类标识
extends：继承，B继承A,放置A，B中间
implements ：接口，跟继承一样，不过可以实现“多继承”
null ：字符串，缺省值
strictfp ：即 strict float point (精确浮点)，strictfp关键字可应用于类、接口、方法，可以让你的浮点运算更加准确；
true ：boolean值，和false是一对，true表示正确的
assert ：断言，这个关键字可以判断布尔值的结果是否和预期的一样，如果一样就正常执行，否则会抛出AssertionError，但不经常使用
const ：常量，修饰之后，则不能再重新赋值，改变
false ：boolean值，和true是一对，false表示错误的
import ：导入，导入哪些java类
package ：包，项目Java文件所在哪个包中
super ：通过当前子类的构造方法调用父类的无参数构造方法。
try ：跟异常有关和catch并用，将预判有异常的代码放入里面
boolean ：boolean 类型，声明布尔使用
continue ：继续，一般在循环中使用，多层循环的情况下，遇到该关键字则跳出当前循环，继续运行
final ：最终的，不可变的，可以修饰变量和方法，类，被修饰的类无法被继承，修饰的方法无法被覆盖，重写，被修饰的变量，就变成常量了，无法重新赋值,不可修饰构造方法
instanceof :保留关键字，左边是对象，右边是类， **System.out.println(o instanceof Student)**返回类型是Boolean类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false
private :私密的，可以用来修饰方法，类，变量，被private修饰的，只能在该类中使用，其他类是无法访问的只能用get,set来设置查看，多用于封装
switch ：循环语句，一般和case,break,continue配合使用
void：空，一般在方法中使用，代替返回值，修饰之后，该方法则不用返回任何值
break ：终止直接把该循环终止不再执行，多层循环是直接中止，不会再执行该循环以外的循环，continue是跳出，
default ：在switch 循环中使用，在case匹配失败的情况下才会执行，特殊情况下，缺少break也会执行
finally ：最后，在异常中使用，不管有没有异常被抛出、捕获，finally块都会被执行。
int ：整型
protected ：被protected修饰的成员对本包内的成员及其子类可见
synchronized ：线程加锁，相对volatile重量级锁
volatile ：轻量级锁，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错
byte ：字节，
do ：与while循环配合使用，置于while前面，在执行while循环前先执行do代码块中的内容
float ：浮点型，单精度小数
interface ：接口，用于修饰类，被修饰的类就成为接口
public ：公共的，可以修饰类，方法，变量，该项目下的所有都可以访问该类方法，变量
this ：这个，
while ：while循环
case ：和switch搭配使用
double ：双精度小数
for ：for循环
long ：长整型
return ：返回值
throw ：表示方法内抛出某种异常对象
catch ：异常处理，和try是一对
else ：否则，和if是一对，逻辑控制
goto ：跳出循环
native ： native 关键字告诉编译器（其实是JVM）调用的是该方法在外部定义，
short ：短整型
throws ：表示这个方法可能抛出某种异常
char ：字符类型
enum ；枚举类型
if ：逻辑控制，如果，和else配对
new ：new，创建新的实例对象
static :静态类型
transient：主要作用就是让某些被transient关键字修饰的成员属性变量不被序列化

String字符串：

String类被final所修饰，所以该类不能被继承，并且他的所有方法都默认被final修饰，一旦被初始化就不能再被修改

常用方法： String str=“ ”;

字符串长度：str.length();
查看字符串中指定字符首次出现的位置：str.indexOf(“a”);
查看字符串中指定字符最后出现的位置，如果是“ ”（没有空格），那么将返回字符串的长度：str.listI ndexOf(“a”);
获取指定索引位置的字符：str.charAt(“a”);
字符串截取：
- str.substring(字符串下标)；//从该下标截取到最后
- str.substring(字符串开始下标，字符串结束下标)；//从开始下标截取到结束下标，结束下标是截取的它们之间的
去首尾空格：str.trim();

//        替换字符串
        System.out.println(str.replace("j", "b"));
//        判断字符串开头与结尾,返回值是布尔类型
        System.out.println(str.startsWith("a"));
        System.out.println(str.endsWith("b"));
//        字符串比较,返回值是布尔值
        System.out.println(str.equals("aa"));//区分大小写
        System.out.println(str.equalsIgnoreCase("aaa"));//不区分大小写
//        字母大小写转换
        System.out.println(str.toLowerCase());//大写转小写
        System.out.println(str.toUpperCase(Locale.ROOT));//小写转大写
//        字符串分割
        System.out.println(str.split("/",2));//regex分隔符，limit分割次数

数组：

数组是具有相同数据类型一组数据的集合

声明：
    数据类型  数组名字[];
	数据类型[]  数组名字;

初始化：
    数组类型 数组名字[]=new 数组元素类型[数组元素的个数];
	数组类型 数组名字[]=new 数组元素类型[]{值1，值2};
	数组类型 数组名字[]={值1，值2};

二维数组：

二维数组常用于表示表，表中信息以行和列的形式组织，第一个下标表示所在行，第二个下标表示元素所在列

声明：

数组元素的类型 数组名字[][];
数组元素的类型[][] 数组名字;

初始化：

先new运算符进行分配，在分别为每一维数组分配内存
 
    int marray[][] = new int[2][4];
    marray[0] = new int[4];
    marray[1] = new int[4];
 
声明同时为数组分配内存

    int marray[][] = {value1,value2,...,value}

数组常用的操作：

数组长度：数组.length
排序（从小到大）：Arrays.sort(数组);
输出数组：Arrays.toString(数组)；

复制数组：

Arrays的copyOf()方法和copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定
长度，copyOfRange()方法则是将指定数组的指定长度复制到一个新数组中。

Arrays.copyOf(arr, int newLength)
Arrays.copyOfRange(arr, int fromIndex, int toIndex)
 
arr：要进行复制的数组对象。
newLength：复制后的新数组长度。如果新数组长度大于数组arr的长度，新位置用0填充。如果复制后的 
           数组长度小于数组arr的长度，则会在数组arr的第一个元素开始截取至满足新数组长度为 
           止。
fromIndex：开始复制数组的索引位置。必须0至整个数组的长度区间，新数组包括索引是fromIndex的元 
           素。
toIndex：复制范围的最后索引位置。可大于arr的长度范围，新数组不包括索引是toIndex的元素

数组查询：

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要
搜索元素的索引值，

binarySearch(Object[] arr, Object key)
binarySearch(Object[] arr, int fromIndex, int toIndex, Object key)
 
arr：要搜索的数组
key：要搜索的值
fromInde：指定范围的开始处索引
toIndex：指定范围内结束出索引
 
binarySearch()方法的返回值
1、如果找到关键字，则返回值为关键字在数组中的位置索引，且索引从0开始
2、如果没有找到关键字，返回值为负的插入点值，所谓插入点值就是第一个比关键字大的元素在数组中的         
   位置索引，而且这个位置索引从1开始。
 
注意：调用binarySearch()方法前要先调用sort方法对数组进行排序，否则得出的返回值不定，这时二分 
      搜索算法决定的。

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
修饰符当前类同一包内子孙类(同一包) 子孙类(不同包) 其他包
public Y Y Y Y Y
protected Y Y Y Y/N N
default Y Y Y N N
private Y N N N N

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

逻辑流程控制

if else:

逻辑控制：
字面意思：
if：如果 else: 否则

if(条件){
    //满足条件进否则直接绕过该代码块里面的东西,比如输出hello
    System.out.print("hello");
}else{
	//不满足则进去该代码块里面,比如输出“你好”
    System.out.print("你好");
}

还有else if：（字面意思也就是，否则如果）

if(条件1){
    //满足条件进否则直接绕过该代码块里面的东西,比如满足条件1输出hello
    System.out.print("hello");
}else if(条件2){
    //满足条件进否则直接绕过该代码块里面的东西,比如满足条件2输出word
    System.out.print("word");
}else{
	//都不满足则进去该代码块里面,比如输出“你好”
    System.out.print("你好");
}

while:

循环就是直接输出一些一样的东西，假如我想打印5遍“小明”

System.out.print("小明");
System.out.print("小明");
System.out.print("小明");
System.out.print("小明");
System.out.print("小明");

但是更多的话就很麻烦了，所以我们循环的用处即使帮我们处理打印一些重复的数据

while(条件){
    //满足条件进入循环执行循环里的内容
    System.out.print("你好");
}

例如你想打印5遍小明就直接吧条件改为“x<5”就可以啦，不过首先你要声明X这个变量：

int x=0;
while(x<5){
    System.out.print("小明");
    x++;
}

这样就可以啦！这是while

do while:

do while是先执行do代码块里的内容再开始，符合条件的情况下再循环打印内容：

也就是说无论符不符合条件都是要执行一次的：

do{
    System.out.print("小明");
    
}while(条件);

while与do while不同的是while不满足条件是一次也不打印的，do while是不满足条件也至少打印一次

for:

for循环也是循环，它与while相似，但是他的条件不像while要在外面声明它是直接内置到条件里面了：

/**
	条件1：初始化表达式，负责完成变量得到初始化,值不再改变。
    条件2：循环条件表达式，值为boolean类型，指定循环条件。
    条件3：循环后操作表达式，负责修正变量，改变循环条件。
 
    当执行for循环时，首先执行条件1，完成初始化工作，下一步判断条件2的值，若条件2为true，则 
    进入循环体，之后进行条件3，结束当前循环体。第二轮循环从条件2开始，若条件2为true，则继续 
    循环，否则跳出整个循环。
    
    for(;;) 这样的表达式表示无限循环，可以用break跳出循环。
    **/
for(条件1;条件2;条件3){
    System.out.print("小明");
}
	


for(int i=0;i<5;i++){
    System.out.print("小明");
}

很显然它与while的区别

for each：

他一般用来遍历数组较为常用：

int[] a={1,2,3,4}
for(int i : a(数组)){
    System.out.print(i);
}

for的话就看着没有for each 这么简洁了：

for(int i=0;i<a.length;i++){
    System.out.print(a[i]);
}

switch:

循环语句，一般和case,break,continue配合使用

switch(条件){
    case value(值) :
       //语句
       break; //可选
    case value(值) :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选，在case匹配失败的情况下才会执行，特殊情况下，缺少break也会执行
       //语句
}

面向对象

类：具有相同行为和相同属性的实体称为类

ps:车是一类但是，越野车，轿车，货车，卡车则是属于车的对象

对象：类是虚拟的一种描述，而对象则是实时存在的实体

全局变量/局部变量 ：通常将类的属性称为全局变量（成员变量），局部变量是声明在方法体内的，全局变量和局部变量都有各自的应用范围

封装：

封装是指把描述一个对象的属性和行为的方法封装在一个类中，实现高内聚，低耦合，防止产生依赖的影响。

继承：

继承是指在定义或实现一个类的时候，可以在一个已存在的类的基础之上来进行，把这个已存在的类所定义的内容作为自己的内容，并可以加入若干新内容，或修改原来的方法，使其更符合本身需求，这就是继承。继承是子类共享父类数据和方法的机制，这是类之间的关系，提高了软件的可用性和可扩展性。

多态:

多态是指父类或接口定义的引用变量指向子类或具体实现类的实例对象，多态就是一个引用，多种实现方式。

接口/抽象

抽象是找出一些事物的共性，将这些共性归为一个类，这个类只考虑这些事物的共性之处。

集合

注解

反射

泛型

IO

枚举

异常

多线程

json

stream流

一种数据格式

Lucky me.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java基础

Java简述JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。JVM：Java Virtual Machine，java虚拟机，用于保证java的跨平台的特性（java语言是跨平台，JVM不是跨平台的）。配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系
复制链接

扫一扫