Java基础须知（运行环境、基本语法）

本文主要是记录Java语言最基础的语法，没事看看，加深印象。

Java运行环境

​ 编译运行过程

​ 第一阶段编译期：.java源文件，经过编译生成.class字节码文件

​ 第二阶段运行期：JVM加载.class文件并运行.class

​跨平台、一次编译到处使用（实现跨平台完全依赖JRE，不同的操作系统，只需要安装对应的Java运行时环境就可以运行）

​JVM：Java虚拟机，加载.class并运行.class
​JRE：Java运行环境，JRE=JVM+Java系统类库（小零件）
​JDK：Java开发工具包，JDK=JRE+编译、运行等命令工具

变量

早期的计算机——算数（数字）
现在的计算机——算数（数字、文字、图片、音频、视频等等）多样化

变量的作用：存数的、代词

定义

在内存中开辟的存储空间，用于存放数据并在过程中要使用。

声明

变量类型 变量名；

//声明一个变量
int a;
//声明多个变量
int a,b,c;

初始化

第一次赋值

//方法一：先声明在初始化
int a;
a = 23;
//方法二：声明的同时初始化
int a = 12;

修改初始值

​同理（赋值运算最后赋值）

使用

1. 对变量的操作即对存储的数据进行使用；
2. 变量的使用必须数据类型匹配；
3. 变量使用前必须声明、必须初始化

命名

标识符

1. 只能包含字母、数字、_和$符，数字不能开头；
2. 区分大小写；
3. 不能用关键字；
4. 可以中文命名，但是不建议。 命名时要做到见名知意

基本数据类型

四类八种

整型类型（byte、short、int、long）、浮点类型（float、double）、char、boolean

类型名称	字节空间	使用场景
byte	1字节	存储字节数据（较常用）
short	2字节	兼容性考虑（很少使用）
int	4字节	存储普通整数（常用）
long	8字节	存储长整数（常用）
float	4字节	存储浮点数（不常用）
double	8字节	存储双精度浮点数（常用）
char	2字节	存储一个字符（常用）
boolean	1字节	存储逻辑变量（常用）

多种数据类型，适应多种应用场景

小知识：
1G=1024M（兆）
1M=1024KB（千字节）
1KB=1024B（字节）
1B=8Bit（位）

int类型

1. 直接量超范围为编译错误
2. 运算时超范围为溢出
3. 整数默认为int类型
4. 两个整数相除不会四舍五入（无条件舍去）
5. 溢出不报错，结果不准确

long类型

需要以L或l结尾（建议大写）

//类型转换计算时，第一个数为大的类型（防止数据溢出）
long a = 10000L*10*3;
long b = 10000*10*3L;
//1970年1月1日零时刻到此时此刻的毫秒数
long time = System.currentTimeMillis();

1秒=1000毫秒

double类型

float类型在使用时加F或f
小数默认为double
不足：存在舍入误差
BigDecimal类：实现精准计算

boolean类型

只能为true或false

char类型

1. 实际上是16位无符号整数，对应不同的字符编码。
2. Java字符类型采用Unicode字符集编码，一个字符对应一个码。
3. ASCII码：a——97；A——65；0——48（0——65535）取值范围
4. 特殊字符：通过‘\’转译

基本数据类型转换

• 两种方式
  1. 自动类型转换
  2. 强制类型转换（可能会数据溢出，丢失精度）
• 两点规则
  1. 整型直接量可以直接赋值给byte、short、char
  2. byte、short、char参与运算转换为int

Scanner接受输入

给变量赋值

1. 固定值
2. 接受用户输入值
3. 系统随机赋值

Scanner scan = new Scanner(System.in);
int age = scan.nextInt();

运算符

• 算数运算符

  1. 加减乘除
  2. %取余
  3. ++、–自增自减
     • 单独使用：在前在后是一样的
     • 被使用时：不一样（a++=a；++a=a+1）

• 关系运算符

  1. <、>
  2. <=、>=
  3. ==、!=

• 逻辑运算符

  &&、||、!（逻辑（短路）与、或、非）能第一时间判断真假时，判断结束。

  //判断是否短路
  if(a>3 && b++>3){
        
        
      ...
  }
  

• 赋值运算符

  1. 简单赋值

     =

  2. 扩展赋值

     +=、-=、*=、%=、/=自带强转

  int a = 3;
  a += 5;//a = a + 5;
  short b = 0；
  b += 4；//自带强转
  b = （short）b + 4;//需要强转
  

• 字符串连接运算符
  +
  字符串和数字转换为字符串

• 三目运算符

  boolean?数1:数2

三种程序结构

顺序结构： 从上往下按顺序执行

分支结构

if(boolean){
    
    
    
}

if(boolean){
    
    
    
}else{
    
    
    
}

if(boolean){
    
    
    
}else if(boolean){
    
    
    
}else{
    
    
    
}

switch...case：多条路

优点：效率高，结构清晰
缺点：整数、相等

int num = 2;
switch(num){
    
    //dyte,short,int,char,String
    case 1:
        System.out.println();
        break;
    case 2:
        System.out.println();
    default:
        System.out.println();
}

循环结构

一定要明确循环变量

int a = 10;
while(a > 0){
    
    //可能一次都不执行
    a--;
    if(a == 3){
    
    
        break;
    }
    if(a == 4{
    
    
        continue;//结束本次循环，进行下一次循环
    }
}

do{
    
    //至少执行一次
    a--;
}while(a > 0);

for(int i=0; i>3; i++){
    
    
    
}

int[] b = {
    
    1,2,3,4,5}
for(int c : b){
    
    
    System.out.println(c);
}

嵌套循环

就是循环里还可以嵌套循环（理论上可以嵌套很多层，但是好的设计不会反复的嵌套）

数组

小常识：

计算机最高的奖项是图灵奖

程序=算法+数据结构

​算法：解决问题的流程

​数据结构：将数据按照某种特定的顺序结构保存

良好的合理的数据结构会导致好的算法好的程序。

数组的定义

1. 一种数据类型（引用数据类型）；
2. 最基本的一种数据结构；
3. 相同数据类型的元素组成的集合；
4. 元素是按照线性顺序排列；

//定义一个长度为10的数组,不赋值（有默认值）
int[] a = new int[10];
//只声明一个数组（只是一个地址）声明不给长度，new的时候给长度同时分配内存空间
//空间大小=数据类型*数组长度
int[] b;
b = new int[]{
    
    3,4,5,6};
//不可以分着写
int[] c = {
    
    1,2,3,4,5};
int[] d = new int[]{
    
    1,2,3,4,5};

数组的访问

1. 通过length获得数组长度；
2. 通过数组下标访问指定数据，数组下标是从0开始的；

数组遍历

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

数组越界异常

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7

数组复制

1.System.arraycopy

int[] x = {
    
    1,2,3,4,5};
int[] y = new int[6];
/*
* 参数：x数组，复制位置，y数组，粘贴位置，复制个数
* 特点：灵活，效率高
* */
System.arraycopy(x,0,y,0,2);
for (int z:y) {
    
    
    System.out.println("z = " + z);
}

2. Arrays.copyof()

/**
         * 方法二
         * 参数：x为要复制的数组，newLength为y数组的长度
         * 优点：可以重新定义数组的长度，扩容
         */
y = Arrays.copyOf(x,7);
for (int s:y) {
    
    
    System.out.println("s = " + s);
}
y = Arrays.copyOf(y,2);
for (int s:y) {
    
    
    System.out.println("s = " + s);
}

排序

数据不同时不同的排序方式，效率也不同；

插入排序、冒泡排序、快速排序；

1.Arrsys.sort()

效率最高，升序

   /**
         * 排序
         */
        int[] g = new int[]{
    
    3,2,6,7,21,1};
        Arrays.sort(g);
        for (int s:g) {
    
    
            System.out.println("g = " + s);
        }

2.冒泡排序

/**
     * 冒泡排序
     * @param a
     * @return
     */
    public int[] sortnew(int[] a){
    
    
        for (int i=0;i<a.length-1;i++){
    
    
            for (int j=0;j<a.length-1-i;j++){
    
    
                if (a[j]<a[j+1]){
    
    
                    int t = 0;
                    t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                }
            }
        }
        return a;
    };

小常识

1. 服务器优化
2. 数据库优化
3. 程序优化

方法

1. 用于封装特定功能的代码特定业务逻辑；
2. 一个方法完成一个特定的功能（只做一件事）；
3. 反复被调用多次；
4. 减少代码的重复，有利于代码的维护，有利于团队的协作。

方法定义

五个要素：修饰词、返回值、方法名、参数列表、方法体
有参更灵活

方法调用

方法分为静态方法和非静态方法
静态方法使用：类名.方法名()
非静态方法使用：类的引用.方法名()
最后声明，以上内容是自己的学习、总结的，分享给大家。如果有不当的地方还请大佬指正交流！