Java基础编程_java编程

Java入门

1. JDK的安装目录介绍

2. HelloWorld案例的编写

1. 新建文本文档文件，修改名称为HelloWorld.java。

注意：后缀名为java的才是java文件。

2. 用记事本打开HelloWorld.java文件，输写程序内容。

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("HelloWorld");
	}
}
1
2
3
4
5

3. 保存

注意：未保存的文件在左上角会有*符号标记

4. 编译文件。编译后会产生一个class文件。

java文件：程序员自己编写的代码。

class文件：交给计算机执行的文件。

5. 运行代码

注意：运行的是编译之后的class文件。

用到两个命令：

​ javac + 文件名 + 后缀名 （就是编译java文件）

​ java + 文件名（运行编译之后的class文件）

3. Java语言跨平台的原理

• 操作系统本身其实是不认识Java语言的。
• 但是针对于不同的操作系统，Java提供了不同的虚拟机。

虚拟机会把Java语言翻译成操作系统能看得懂的语言。

4. JRE和JDK

JVM（Java Virtual Machine），Java虚拟机

JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）

JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。

Java基础语法

1. 注释

​ 注释是对代码的解释和说明文字。

Java中的注释分为三种：

• 单行注释：

// 这是单行注释文字
1

• 多行注释：

/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
注意：多行注释不能嵌套使用。
1
2
3
4
5
6

• 文档注释：

/**
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
1
2
3
4
5

2. 关键字

2.1 概念

​ 被Java赋予了特定含义的英文单词。

​ 当我们在代码中写了关键字之后，程序在运行的时候，就知道要做什么事情了。

2.2 第一个关键字class

​ 表示定义一个类。创建一个类。

类：Java项目最基本的组成单元，一个完整的Java项目有可能会有成千上万个类来组成的。

class后面跟随的就是这个类的名字，简称：类名。

在类名后面会有一对大括号，表示这个类的内容。

举例：

public class HelloWorld{
    
   
}
1
2
3
4

解释：class表示定义类。

​ 类名：HelloWorld

​ HelloWorld后面的大括号表示这个类的范围。

3. 字面量

作用：告诉程序员，数据在程序中的书写格式。

4. 变量

4.1 什么是变量？

​ 变量就在程序中临时存储数据的容器。但是这个容器中只能存一个值。

4.2 变量的定义格式

​ 数据类型 变量名 = 数据值；

4.2.1 格式详解

​ 数据类型：限定了变量当中能存储什么类型的数据。

​ 如果要存10，那么数据类型就需要写整数类型。

​ 如果要存10.0，那么数据类型就需要写小数类型。

​ 变量名：其实就是这个容器的名字。

​ 当以后想要使用变量里面的数据时，直接使用变量名就可以了。

​ 数据值：真正存储在容器中的数据。

​ 分号：表示语句的结束，就跟以前写作文时候的句号是一样的。

4.2.2 常用的数据类型

​ 整数：int

​ 小数：（浮点数）double

4.2.3 变量的注意事项

• 变量名不能重复
• 在一条语句中，可以定义多个变量。但是这种方式影响代码的阅读，所以了解一下即可。
• 变量在使用之前必须要赋值。

public class VariableDemo2{
	public static void main(String[] args){
		//1.变量名不允许重复
		//int a = 10;
		//int a = 20;
		//System.out.println(a);
		
		//2.一条语句可以定义多个变量
		//了解。
		//int a = 10, b = 20, c = 20,d = 20;
		//System.out.println(a);//?
		//System.out.println(b);//?
		
		
		//3.变量在使用之前必须要赋值
		int a = 30;
		System.out.println(a);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5. 数据类型

5.1 Java语言数据类型的分类

• 基本数据类型
• 引用数据类型（主要在面向对象的时候会用到）

5.2 基本数据类型的四类八种

说明

​ e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。

​ 在java中整数默认是int类型，浮点数默认是double类型。

需要记忆以下几点

byte类型的取值范围：

​ -128 ~ 127

int类型的大概取值范围：

​ -21亿多 ~ 21亿多

整数类型和小数类型的取值范围大小关系：

​ double > float > long > int > short > byte

5.3 定义8种基本数据类型变量

public class VariableDemo3{
    public static void main(String[] args){
        //1.定义byte类型的变量
        //数据类型 变量名 = 数据值;
        byte a = 10;
        System.out.println(a);

        //2.定义short类型的变量
        short b = 20;
        System.out.println(b);

        //3.定义int类型的变量
        int c = 30;
        System.out.println(c);

        //4.定义long类型的变量
        long d = 123456789123456789L;
        System.out.println(d);

        //5.定义float类型的变量
        float e = 10.1F;
        System.out.println(e);

        //6.定义double类型的变量
        double f = 20.3;
        System.out.println(f);

        //7.定义char类型的变量
        char g = 'a';
        System.out.println(g);

        //8.定义boolean类型的变量
        boolean h = true;
        System.out.println(h);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

6. 标识符

大多数程序员都在遵守阿里巴巴的命名规则。

6.1 硬性要求：

​ 必须要这么做，否则代码会报错。

• 必须由数字、字母、下划线_、美元符号$组成。
• 数字不能开头
• 不能是关键字
• 区分大小写的。

6.2 软件建议：

​ 如果不这么做，代码不会报错，但是会让代码显得比较low。

6.2.1 小驼峰命名法

适用于变量名和方法名

• 如果是一个单词，那么全部小写，比如：name

• 如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge

6.2.2 大驼峰命名法

适用于类名和接口名

• 如果是一个单词，那么首字母大写。比如：Demo、Test。

• 如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld

不管起什么名字，都要做到见名知意。

阿里巴巴命名规范细节：

1. 尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。

   正确：alibaba、hangzhou、nanjing

   错误：jiage、dazhe

2. 平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。

   错误：_name

   正确：name

类名和接口名首字母都要大写，变量名和方法名第一个单词小写，从第二个单词开始首字母大写

7. 键盘录入

​ 键盘录入的实际功能Java已经帮我们写好了，不需要我们自己再实现了，而Java写好的功能都放在了Scanner这个类中，所以，我们只要直接使用Scanner这个类就可以了。

使用步骤：

第一步：

​ 导包：其实就是表示先找到Scanner这个类在哪。

第二步：

​ 创建对象：其实就表示申明一下，我准备开始用Scanner这个类了。

第三步：

​ 接收数据：也是真正干活的代码。

代码示例：

//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
	public static void main(String[] args){
		//2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
		Scanner sc = new Scanner(System.in);
		//3.接收数据
		//当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
		System.out.println("请输入一个数字");
		int i = sc.nextInt();
		System.out.println(i);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

8. IDEA中层级结构介绍

8.1.1 结构分类

• project（项目、工程）
• module（模块）
• package（包）
• class（类）

project（项目、工程）

​ 淘宝、京东网站都属于一个个项目，IDEA中就是一个个的Project。

module（模块）

​ 在一个项目中，可以存放多个模块，不同的模块可以存放项目中不同的业务功能代码。。

package（包）

​ 一个模块中又有很多的业务，为了把这些业务区分的更加清楚，就会用包来管理这些不同的业务。

class（类）

​ 就是真正写代码的地方。

8.1.2 小结

• 层级关系

  ​ project - module - package - class

• 包含数量

  ​ project中可以创建多个module
  ​ module中可以创建多个package
  ​ package中可以创建多个class

  ​ 这些结构的划分，是为了方便管理类文件的。

运算符

1.运算符和表达式

运算符：

​ 就是对常量或者变量进行操作的符号。

​ 比如： + - * /

表达式：

​ 用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。

​ 比如：a + b 这个整体就是表达式。

​ 而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。

2.算术运算符

分类：

+ - * / %
1

运算特点：

+ - * :跟小学数学中一模一样没有任何区别.


/：
1.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。
2.小数直接参与运算，得到的结果有可能是不精确的。
案例：
System.out.println( 10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335


%：取模、取余。
   他做的也是除法运算，只不过获取的是余数而已。
案例：
System.out.println(10 % 2);//0
System.out.println(10 % 3);//1
应用场景：
//可以利用取模来判断一个数是奇数还是偶数
System.out.println(15 % 2);//1  奇数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.隐式转换

概念：

​ 也叫自动类型提升。

​ 就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。

简单记忆：

​ 就是小的给大的，可以直接给。

两种提升规则：

• 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
• byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。

取值范围从小到大的关系：

​ byte short int long float double

4.强制转换

概念：

​ 如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。

​ 如果一定要这么干，就需要加入强制转换。

书写格式：

​ 目标数据类型 变量名 = （目标数据类型）被强转的数据；

简单理解：

​ 要转成什么类型的，那么就在小括号中写什么类型就可以了。

案例：

public class OperatorDemo2 {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;
        System.out.println(b);//12
    }
}
1
2
3
4
5
6
7

注意点：

​ 强制转换有可能会导致数据发生错误。（数据的精度丢失）

5.字符串的+操作

核心技巧：

• 当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
• 当连续进行+操作时，从左到右逐个执行的。

案例1：

1 + "abc" + 1
1

结果：“1abc1”

解释：

​ 第一步： 1 + “abc”。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"1abc"

​ 第二步： “1abc” + 1。这个过程中，有字符串参与的，所以做的也是拼接操作，产生一个新的字符串"1abc1"

案例2：

1 + 2 + "abc" + 2 + 1
1

结果：“3abc21”

解释：

​ 第一步：1 + 2 。在这个过程中，没有字符串参与的，所以做的是加法运算，结果为3。

​ 第二步：3 + “abc”。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"3abc"。

​ 第三步：“3abc” + 2。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"3abc2"。

​ 第四步：“3abc2” + 1。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串“3abc21”

案例3：

String name = "黑默丁格";
System.out.println("我的名字是" + name);
1
2

结果： 我的名字是黑默丁格

解释：当字符串跟变量相加的时候，实际上是跟变量里面的值进行拼接。

6.字符的+操作

规则：

​ 当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

案例：

char c = 'a';
int result = c + 0;
System.out.println(result);//97
1
2
3

ASCII码表中：

​ ‘a’ ----- 97

​ ‘A’ ----- 65

7.自增自减运算符

分类：

++  自增运算符  //就是把变量里面的值+1
--  自减运算符  //就是把变量里面的值-1
1
2

使用方式：

• 放在变量的前面，我们叫做先++。 比如：++a
• 放在变量的后面，我们叫做后++。 比如：a++

注意点：

​ 不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。

8.赋值运算符

最为常用的： =

运算过程：就是把等号右边的结果赋值给左边的变量

9.扩展赋值运算符

分类：

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

运算规则：

​ 就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

案例：

public class OperatorDemo7 {
    public static void main(String[] args) {
        //扩展赋值运算符
        int a = 10;
        int b = 20;
        a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响
        // 相当于 a = a + b;
        System.out.println(a);//30
        System.out.println(b);//20
    }
}
1
2
3
4
5
6
7
8
9
10
11

注意点：

​ 扩展的赋值运算符中隐层还包含了一个强制转换。

以+=为例。

a += b ;实际上相当于 a = (byte)(a + b);

public class OperatorDemo8 {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        //a += b;
        a = (byte)(a + b);
        System.out.println(a);//30
    }
}
1
2
3
4
5
6
7
8
9

10.关系运算符

又叫比较运算符，其实就是拿着左边跟右边进行了判断而已。

分类：

注意点：

• 关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
• 在写==的时候，千万不要写成=

11.逻辑运算符

& 和 | 的使用：

&：逻辑与（而且）

​ 两边都为真，结果才是真，只要有一个为假，那么结果就是假。

|：逻辑或（或者）

​ 两边都为假，结果才是假，只要有一个为真，那么结果就是真。

^（异或）的使用：

​ 用的不多，了解一下即可。

计算规则：如果两边相同，结果为false，如果两边不同，结果为true

!（取反）的使用：

​ 是取反，也叫做非。

计算规则：false取反就是true，true取反就是false

温馨提示：取反最多只用一个。

12. 短路逻辑运算符

分类： && ||

&&：

​ 运算结果跟&是一模一样的，只不过具有短路效果。

||：

​ 运算结果跟|是一模一样的。只不过具有短路效果。

逻辑核心：

​ 当左边不能确定整个表达式的结果，右边才会执行。

​ 当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。

13.三元运算符

又叫做：三元表达式或者问号冒号表达式。

格式：

​ 关系表达式 ？ 表达式1 ：表达式2 ；

计算规则：

• 计算关系表达式的值。
• 如果关系表达式的值为真，那么执行表达式1。
• 如果关系表达式的值为假，那么执行表达式2。

注意点：

​ 三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。

案例：

public class OperatorDemo12 {
    public static void main(String[] args) {
        //需求：求两个数的较大值
        int a = 10;
        int b = 20;

        //格式：关系表达式 ？ 表达式1 ： 表达式2 ；
        //注意点：
        //三元运算符的最终结果一定要被使用。
        //要么赋值给一个变量，要么直接输出。
       int max =  a > b ? a : b ;
        System.out.println(max);


        System.out.println(a > b ? a : b);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17