Java基础

最新推荐文章于 2025-06-04 16:07:42 发布

童年655

最新推荐文章于 2025-06-04 16:07:42 发布

阅读量98

点赞数

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_72014003/article/details/129020949

版权

本文介绍了Java的开发环境，包括JVM、JRE和JDK的区别与作用，强调了开发和运行Java程序所需环境。此外，提到了IDEA作为开发工具的使用，并概述了Java编程的基本元素如数据类型、运算符和循环结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java开发环境：

编译运行过程：

编译期： .java源文件，经过编译，生成 .class字节码文件

运行期：JVM 加载并运行 .class字节码文件（0和1）

特点：跨平台，一次编译到处使用

名词：

JVM：java虚拟机

加载并运行 .class字节码文件

JRE：java运行环境

除了包含JVM之外，还包含了运行java程序所必须的环境

JRE=JVM+java系统类库（小零件）

JDK：java开发工具包

除了包含JRE之外，还包含了开发java程序所必须的命令工具

JDK=JRE+编译、运行等命令工具

注意：运行java程序的最小环境是JRE，开发java程序的最小环境是JDK

题外：本人刚开始学的时候，是用记事本写的最基本的“hello world”，现在为了简化工作量，以及避免不必要的字母拼写错误，都是使用idea进行java开发，初学者也可以试试安装JDK，配置完环境变量之后，用记事本编写，命令行使用javac、java命令试一试

关于idea：

JetBrains公司的，分为社区版(免费的)和终级版(收费的)

开发步骤：

新建Java项目/工程--------------------------小区

新建Java包-------------------------------------楼+单元

新建Java类-------------------------------------房子

main中：System.out.println("hello world");

package first; //声明包first(楼+单元)
public class HelloWorld { //声明类HelloWorld(房子)
    //主方法，为程序的入口(房子大门口)，程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {
        //输出hello world
        //1)严格区分大小写
        //2)所有符号必须是英文模式的
        //3)每句话必须以分号结尾
        System.out.println("hello world"); //双引号中的原样输出
        System.out.println("欢迎大家学习JAVA");
    }
}

变量：

简单打个比方：去银行存款

变量：就相当于存数的

变量的声明：去银行开户

变量的命名：给账户取名

命名只能使用数字、字母、_(下划线)和$符号，数字不能作为开头

严格区分大小写

不能使用关键字

允许中文命名，但不建议，建议以英文的“见名知意”、“小驼峰命名法”

变量的初始化：给账户存钱

变量的使用：使用的是账户里的钱

对变量的使用，就是对它所存的那个数的使用

变量在使用之前，必须声明并初始化

当然，合理的利用开发工具，也能有效避免以上错误

八大基本数据类型：

byte：字节型，占用1个字节（8位二进制）取值范围 -2的7次幂 ~2的7次幂-1

short：短整型，占用2个字节（16位二进制）取值范围 -2的15次幂 ~2的15次幂-1

int：整型，占用4个字节（32位二进制）取值范围 -2的31次幂 ~2的31次幂-1

整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误

两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)

整数运算时若超范围，则发生溢出，溢出不是错误，但需要避免

long：长整型，占用8个字节（64位二进制）取值范围 -2的63次幂 ~2的63次幂-1

长整型直接量需在数字后加L或l

运算时若有可能溢出，建议在第1个数字后加L

float：单精度浮点型，占用4个字节（32位二进制）不能准确表示数值

double：双精度浮点型，占用8个字节（64位二进制）不能准确表示数值

小数直接量默认为double型，若想表示float，需在数字后加F或f

不能精确表示数据，运算时有可能会发生舍入误差，精确运算场合不能使用

boolean：布尔型，占用1个字节（8位二进制）只能存储true和false

char：字符型，占用2个字节（16位二进制）采用Unicode编码格式，一个字符对应一个码，表现的形式是字符char，但本质上是int

ASCII码：'a'----97 'A'----65 '0'----48

类型之前转换

两种方式:

自动/隐式转换:小类型到大类型

int a = 10000000;
long b = a;

强制类型转换：大类型到小类型

语法：(要转换成为的数据类型)变量

注意：强转有可能会溢出或丢失精度

long a = 10000000L;
int b = (int)a;

两点规则：

整数直接量可以直接给byte,short,char赋值，但不能超出范围

byte,short,char型数据参与运算时，系统会将其一律自动转换为int再运算

运算符:

算术：+、-、*、/、%、++、--

++/--:自增1/自减1，可在变量前也可在变量后

单独使用时，在前在后都一样

被使用时，在前在后不一样

a++的值为a------------(a--的值为a)

++a的值为a+1--------(--a的值为a-1)

关系：>、<、>=、<=、==、!=

逻辑：&&、||、!

&& 短路与 ( || 短或) 在连接多个boolean判断时,第一个为假(真),后面就直接不执行了(因为已经能够判断最终的结果时false或true了)

赋值：=、+=、-=、*=、/=、%=

字符串连接：+

若两边为数字，则做加法运算

若两边出现了字符串，则做字符串连接

任何类型与字符串连接，结果都是字符串型

System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String

条件/三目：boolean?数1:数2

整个条件运算是有值的，它的值要么是?号后的数1，要么是:号后的数2

计算boolean的值:

若为true，则整个表达式的值为?号后的数1

若为false，则整个表达式的值为:号后的数2

int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1

int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max); //max=8

还有进行二进制运算的位运算符 <<(左移),>>(右移),相比于传统的加减乘除,位运算符是直接对二进制数值进行操作,效率上是比普通运算高的

分支结构:

一条路: if 结构

1)语法:if(boolean){    
    语句块------------基于条件执行的语句
      }
2)执行过程:  判断boolean的值:    
    若为true，则执行语句块(整个结束)   
    若为false，则直接结束

//1)偶数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//2)满500打8折:
double price = 300.0; //消费金额   带数(600.0,300.0)
if(price>=500){ //满500
    price*=0.8; //打8折
}
System.out.println("最终消费金额为:"+price);

//3)判断成绩合法------在0到100之间(包括)
double score = 850;  //带数(95,850,-54)
if(score>=0 && score<=100){
    System.out.println("成绩合法");
}
System.out.println("继续执行...");

两条路: if...else...结构

1)语法:if(boolean){
    语句块1
  }else{
    语句块2
  }
2)执行过程:
  判断boolean的值:
    若为true，则执行语句块1(整个结束)
    若为false，则执行语句块2(整个结束)
3)说明:
    语句块1和语句块2，必走其中之一------------2选1

//1)偶数、奇数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}else{
    System.out.println(num+"是奇数");
}
System.out.println("继续执行...");

//2)满500打8折，不满500打9折:
double price = 300.0; //带数(600.0,300.0)
if(price>=500){
    price *= 0.8;
}else{
    price *= 0.9;
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩是否合法---0到100(包括)之间表示合法，否则为不合法
double score = -25; //带数(95,540,-25)
if(score>=0 && score<=100){
    System.out.println("成绩合法");
}else{
    System.out.println("成绩不合法");
}

多条路: if...else if...结构

1)语法:if(boolean-1){
    语句块1
  }elseif(boolean-2){
    语句块2
  }elseif(boolean-3){
    语句块3
  }else{
    语句块4
  }
2)执行过程:
    判断boolean-1，若为true则执行语句块1(结束)，若为false则
    再判断boolean-2，若为true则执行语句块2(结束)，若为false则
    再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
3)说明:
    语句块1/2/3/4，必走其中之一------------多选1

//成绩等级判断
public class ScoreLevel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        double score = scan.nextDouble();

        //带数(888,-45,95,85,65,45)
        if(score<0 || score>100){
            System.out.println("成绩不合法");
        }else if(score>=90){ //合法
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }
    }
}

switch...case结构：

也是多路结构

优点：效率高，结构清晰

缺点：只能对几种数据类型判断相等

支持的类型：byte，short，int，char，String，以及枚举类型

break：用于跳出switch

//命令解析程序
public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.存款 2.取款 3.退卡");
        int command = scan.nextInt();

        switch(command){
            case 1:
                System.out.println("存款业务处理...");
                break;
            case 2:
                System.out.println("取款业务处理...");
                break;
            case 3:
                System.out.println("退卡");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

注意：如果各分支下不写break 关键字，则会进行穿透效果；default语句，不管写在哪都是在case之后执行，推荐写在最后

循环结构：

循环：反复多次执行一段相同或相似的代码

循环三要素：

循环变量的初始化

循环的条件（以循环变量为基础）

循环变量的改变（向着循环结束变）

循环变量：在整个循环过程中所反复改变的那个数

while结构：先判断后执行，有可能一次都不执行

语法:

    1)语法:while(boolean){
        语句块/循环体----------反复执行的代码
      }
    
    2)执行过程:
        先判断boolean的值，若为true则执行语句块，
        再判断boolean的值，若为true则再执行语句块，
        再判断boolean的值，若为true则再执行语句块，
        如此反复，直到boolean的值为false时，while循环结束

do...while结构:先执行后判断，至少执行一次

建议:当要素1与要素三代码相同时,首选do...while

语法:

    1)语法:do{
        语句块
      }while(boolean);
    2)执行过程:
        先执行语句块，再判断boolean的值，若为true则
        再执行语句块，再判断boolean的值，若为true则
        再执行语句块，再判断boolean的值，若为true则
        再执行语句块，如此反复，直到boolean的值为false时，do...while结束

for循环结构:应用率最高，与次数相关的循环

    1)语法:
    //    1    2     3
    for(要素1;要素2;要素3){
        语句块/循环体---------------反复执行的代码 4  
    }
    2)执行过程:
    1243243243243243...2

任何复杂的业务逻辑都可以通过三种结构来实现：

顺序结构：从上往下逐行执行，每句必走

分支结构：有条件的执行某语句一次，并非每句必走

循环结构：有条件的执行某语句多次，并非每句必走

变量的作用域/范围：

从变量的声明开始，到包含它最近的大括号结束

三种循环结构如何选择：

先看循环是否与次数相关：

若有关-----------------------------------------------直接上for

若无关，再看要素1与要素3是否相同

若相同------------------------------------------直接上do...while

若不同------------------------------------------直接上while

continue：跳过循环体中剩余语句而进入下一次循环

嵌套循环:

循环中套循环，常常多行多列时使用，外层控制行，内层控制列

执行规则：外层循环走一次，内层循环走所有次

建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层

break只能跳出当前一层循环

 for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i+"x"+j+"=" +i*j+"\t");
            }
            System.out.println();
        }

待续...