Java语言基础学习笔记

Domineering的薄荷

已于 2024-01-10 11:51:15 修改

阅读量437

点赞数 1

文章标签： java 开发语言学习笔记

于 2023-11-02 23:04:27 首次发布

本文链接：https://blog.csdn.net/2302_80249284/article/details/134163654

版权

一、Java编程语言

1.1 什么是Java编程语言

什么是编程语言：是人类与计算机沟通的桥梁。

什么是Java编程语言：Java编程语言是编程语言的一种，人类使用Java编程语言，就可以间接地操作计算机了。

1.2 Java语言发展史

Java语言是美国Sun公司在1995年推出的计算机语言

Java之父：詹姆斯•高斯林

Java 早期叫 oak( 橡树 ), 后期改名为Java。2009 年 sun 公司被 oracle( 甲骨文 ) 收购

1.3 JDK、JRE、JVM

JDK：Java Development Kit (Java开发工具包) 。是开发Java程序使用的工具包，可以编译运行Java程序，因为是工具包，所以必须要安装jdk才能运行Java。

JRE ： Java Runtime E nvironment (Java 运行环境 ) ：是 Java 程序运行的最小环境

JVM： J ava V irtual M achines (Java 虚拟机 ) ：用于执行 Java 字节码

注：1.运行Java程序需要使用JRE

2.开发Java程序需要使用JDK

二、Java基础语法

2.1.注释

Java中主要有以下3类注释

单行注释

格式：// 内容或 //两斜杠以上内容，只能注释一行内容

多行注释

格式：/* 内容 */ ，能注释多行内容

文档注释

格式：/** 内容 */，也能注释很多内容（一般用不上）

注：注释不是编程语句，因此不会被执行。

2.2.关键字

概述：关键字，（又称保留字）被Java语言赋予了特殊含义的单词。具有特殊的意义和用途，不能随便被用作一般的标识符来使用。（有50多个关键字）

特点：关键字的所有字母全部小写，大写表示含义完全不同

常用的代码编辑器对关键字有特殊的颜色标记。

2.3.常量

（1）什么是常量：如3.1415726535…很长的数，我们定义它为Π，通常取3.14，Π=3.14这个就是常量。即常量：在程序运行过程中，其值不可以发生改变的量。

（2）常量分类：

常量类型	说明	举例
字符串常量	用" "引起来的内容	"Hello World"，"你好"
整数常量	不带小数的数字	666 ，-88
小数常量	带小数的数字	13.14 ，-5.21
字符常量	用' '引起来的内容	' A ' ，' 0 ' ，' 我 '
布尔常量	布尔值表示真假	只有两个值：true ，false
空常量	一个特殊的值或空值	null

注：空常量null不能直接输出！！！

2.4.数据类型

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也有不同的储存空间，数据大小也不一样。

数据类型分为：基本数据类型、引用数据类型
基本数据类型分为：数值型、非数值型
引用数据类型：字符串、用户自定义类型
数值型分为：整数（byte,short,int,long）、浮点数（float,double）、字符（char） char只能表示一个字符，是用来查unicorn编码集里对应编码
非数值型分为：布尔（boolean）、类（class）、接口（interface）、数组（[ ]）

类型名称	关键字	占用内存	取值范围
字节型	byte	1字节	-128～127
短整型	short	2字节	-32768～32767
整型	int	4字节	-2147483648～2147483647
长整型	long	8字节	-9223372036854775808L～9223372036854775807
单精度浮点型	float	4字节	+/-3.4E+38F（6～7个有效位）
双精度浮点型	double	8字节	+/-1.8E+308（15个有效位）
字符型	char	2字节	ISO单一字符集
布尔型	boolean	1字节	true 或 false

类型默认值

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	'u0000'
String（or any object）	null
boolean	false

2.5.变量

2.5.1变量的概述

（1）什么是变量：如想改变一个值，让所有这个值都发生改变，就是变量。

即：在程序运行过程中，其值可以发生改变的量。

（2）变量定义：

格式：数据类型变量名 = 变量值 int a = 10;

如： int a = 10; //定义变量

System.out.println(a); //输出变量

2.5.2变量的使用

变量赋值：（1）普通赋值（一步）：int age = 20;

String name = "张三";

（2）先声明，后赋值（两步）：int age;

age = 20;

String name;

name = "张三";

2.变量使用的注意事项：

long长整型的变量定义的时候，后面要加L；
float单精度浮点型的变量定义的时候，后面要加F；double双精度浮点型，后面也可以加D。

2.6.标识符

2.6.1标识符定义规则

由数字、字母、下划线“_”、美元符号“$”组成，并且所有符号里不能有空格；
不能以数字开头；
不能是Java关键字或保留字；
Java严格区分大小写，如：Class，C大写是符合规则的。

2.6.2标识符命名规范

小驼峰命名法：方法、变量

标识符是一个单词时，字母全部小写，如：name；
由多个单词组成时，第一个单词首字母小写，后面单词首字母都大写，如：firstName。

2. 大驼峰命名法：类

标识符是一个单词时，首字母大写，如：Student；
由多个单词组成时，每个单词首字母都大写，如：GoodStudent。

3. 做到见名知意

尽量不要用拼音，除一些国际通用的拼音可视为英文单词，否则显得很low；
起变量名、方法名、类名候，不能使用下划线“_”或美元符号“$”。

2.7.类型转换

概念：把一个表示数据范围小的变量赋给另一个表示数据范围大的变量。

2.7.1 自动类型转换

2.7.2 强制类型转换

概念：把一个表示数据范围大的变量赋给一个范围小的变量。

格式：目标数据类型变量名 =（目标数据类型）值或变量

三、运算符与表达式

3.1. 算术运算符

在数学运算中最常见的就是加减乘除，被称作四则运算，在JAVA中的四则运算也是跟常理的一模一样。接下来通过一张表来展示JAVA中的运算符及其用法。

运算符	运算	范例	结果
+	加	1+2	3
-	减	2-1	1
*	乘	2*4	8
/	除	5/5	1
%	取模（求余数）	7%5	2
++	自增（前）	a=2;b=++a;	a=3;b=3
--	自减（前）	a=2;b=--a;	a=1;b=1
++	自增（后）	a=2;b=a++;	a=3;b=2
--	自减（后）	a=2;b=a--;	a=1;b=2

注：

++ 单独使用时：

++ 在前面和在后面没有什么区别，都是对变量进行自加 1

++ 参与其他数值运算时：

++ 在前面，先对变量自加 1 ，再拿自加后的值参与运算。

++ 在后面，先变量自身参与运算。再变量自身加 1

（--同样道理）

3.1.1字符串的"+"操作

当字符串里出现"+"时，是直接拼接字符。如：System.out.println("结果为"+2); //结果为2
当字符串里"+"出现在第一个运算就会进行相加操作。System.out.println(1+100"我"); //100我

3.2. 赋值运算符

赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量。接下来通过一张表来展示JAVA中的运算符及其用法。

3.3. 比较运算符

比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。

=是赋值，==是比较

3.4. 逻辑运算

逻辑运算符用于对布尔型的数值进行操作，其结果仍是一个布尔型数据。

3.4.1 结论

&&有false则false

||有true则true

^所有符号相同为false，不同为true

!真假转换

3.4.2短路现象

结论

&&：第一个表达式确定了结果，第一个表达式为false，结果就为false。如果第一个true，&和&&就没区别。

||：同上，和&&想反，第一个表达式为true，结果就为true。如果第一个false，|和||就没区别。

3.5.三元运算符（三目运算符）

（1）格式：数据类型变量名 = 关系表达式? 表达式 2 ：表达式 3;

例： int a = 10 > 20 ? 3.14 : 4.14;

运算顺序：

首先计算关系表达式，值为true/false，但是不会输出这两个单词；
如果为true，表达式2就为结果；
如果为false，表达式3就为结果。

（2）数据输入：Scanner类

导包：import java.util.Scanner; //出现在类定义的上方
创建对象：Scanner sc = new Scanner (System.in); //这句代码只有sc是变量名可以变，其他都不允许变
接收数据：int i = sc.nextInt( )； //只有 i 能变，. 前的类要和上面的一样 sc要和上一句对应
输出：让用户输数据

例：任意给出一个整数，判断是奇数还是偶数，并输出奇数/偶数

import java.util.Scanner;

public class jichuyuju {
public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = sc.nextInt();
        if (number % 2 == 0) {
      System.out.println(number + "该整数是偶数");
        } else {
System.out.println(number + "该整数是奇数");
        }

}

四、流程控制语句

4.1 顺序结构

之前在前面学是都是顺序结构，属于最简单的。

4.2分支结构

4.2.1 if 条件语句

1. if 语句

结构1：

执行流程：

首先计算关系表达式的值；
关系表达式的值为true执行语句体；
相反false不执行与具体直接执行后面的语句内容。

2. if …else 语句

结构2：

执行流程：

关系表达式为true执行语句1；
false为语句2；
继续执行后面的语句内容。

3. if …else if …else语句

结构3：

执行流程：

同上，若if 和else if里有关系表达式为true，就执行该表达式下的语句。
如果没有任何关系表达式为true，则执行else 语句体n+1。

4.2.2 switch语句

格式：

swich (表达式){
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ……;
    default:
        语句体n+1;
        break;  //可写可不写
    }

格式说明：

表达式可以是byte short int，还可以是String;
case后面跟的是要和表达式进行比较的值
break表示中断结束switch语句。
default没有匹配项，和if语句的else相似

执行流程：

首先计算表达式的值，然后和case后面的值比较
遇到相配的就执行break结束输出相对应与具体
如果没有匹配到，就执行default里的语句体。

注意：

如果中间不写break，程序就向下执行，称为case穿透。
case后面的值只能是字面量，不能是变量。
case后面的值不允许重复。

2. switch的简化代码

省略语句体下面的break，用短杠 - 和小于 < 号代替

4.2.3 if 和 switch语句比较

if在功能上远远大于switch, if 适合做条件区间判断。
当前条件是区间的时候应该使用if分支语句。
当前条件是与一个一个的值比较的时候，switch分支更合适，格式性能更好，代码简洁。

4.3 循环结构

4.3.1. for 循环结构

for循环语句是最常用的循环语句，一般在循环次数已知的情况下。

格式：

for (1.初始化语句;2.条件判断语句;4.条件控制语句){
    3.循环体语句;
}
条件判断语句如果不满足，循环就结束
条件判断语句后面执行的是循环体语句，然后才是条件控制语句
输出不代表结束，然后根据2的条件，然后执行3.最后执行4.以此循环。求和变量要定义在此循环的外面。

题目：

for循环的变形

int i = 0；
for( ;i < 4;i++){
    System.out.println(i);
}
所以 初始化语句可以定义在循环外面，里面不写

4.3.2 while 循环结构

格式：

初始化语句；
while(条件判断语句){
    循环体语句;
    条件控制语句;
}

执行流程：

按顺序执行
执行条件判断语句时，false结束，true继续执行
执行完条件控制语句后，回到条件判断语句继续执行

例：有一张足够大的纸，厚度0.1mm,请问折多少次，能超过珠穆朗玛峰的高度（8844.43米）

4.3.3 do…while循环结构

格式：

初始化语句;              
do{    //do后面不加()           
    循环体语句;
    条件控制语句;
}
while (条件判断句);

执行流程：

执行初始化语句
执行循环体语句
执行条件控制语句
执行条件判断语句时，false结束，true继续执行
回到2继续循环。

特点：先执行，后判断。

4.3.4 三种循环小结

for 、while循环先判断后执行, do…while循环先执行后判断。
for 、while循环执行流程一模一样，功能上无区别
清楚循环次数用for，不清楚的用while
for控制变量只在循环中，while在循环外
不满足循环条件时，while循环一次都不会执行，而do…while至少会执行一次。

4.4 循环搭配

break、cuntinue、return

break结束当前整个for循环，继续执行下面语句。
continue表示结束当前的循环（是结束当前最小的循环，如for里面的if），接着执行

3. return在循环中的两个作用

可以单独使用：表示结束整个方法，（如main主方法）
不能单独使用：return返回值，需要使用在有要求返回值的方法中，return一般写在最后一行void和return不能一起出现，void是指没有返回值

4.5 Random使用

作用：随机生成随机数

导包
写随机数代码 Random a = new Random( );
调用随机数功能：int number = r.nextInt(10);

五、数组

概念：数组是一组数据的集合，也称是一种容器，数组中的每个数据被称作为元素。数组可以放任意类型的元素，但同一个数组里存放元素类型必须一致。

数组可以分为一维数组、多维数组。

定义格式：

数据类型 [ ] 变量名如：int [ ] arr 定义了一个int类型数组，数组名是arr
数据类型变量名 [ ] 如：int arr [ ] 定义了一个int类型变量，变量名是arr数组

5.1 数组的静态初始化

概念：是指在内存中，为数组容器开辟空间，并将数据存入容器的过程。

完整格式：数据类型 [ ] 数组名 = new数据类型 [ ] { 元素1,元素2,元素3…… };

简写格式：数据类型 [ ] 数组名 = { 元素1,元素2,元素3…… };

例：

int[]arr = new int[]{1,2,3,4};
String [] arr1 = new String[]{"张三","李四"}；
double [] arr2 = {1.21,1.12,1.11};

5.1.2 数组在内存中的分配情况

例：

int [ ] ages = {12,23,34}; //数组是一种引用数据类型，储存数组在内存中的地址信息。

例2：

第一张图：第一行代码 int [ ] = x;声明了一个变量x，该变量的类型为 int [ ]，即一个int类型的数组。变量x占用了一块内存单元，但是它没有被分配初始值。

第二张图：第二行代码 x = new int [100];创建了一个数组，将数组的地址赋给变量x。用变量x来引用数组，这时内存中的状态就会发生变化。

第二张图中描述了变量x引用数组的情况，该数组中有100个元素，初值都为0。要想访问数组中的元素，可以通过x [0]、x [1]、x [2]……这样的形式。但需要注意的是，数组中最小索引是0，最大索引是 " 数组的长度 -1 "（下面会讲到数组长度的访问）。

5.2 数组的元素访问

5.2.1 访问单个元素

数组通过下标来访问内部元素，数组索引一定是从0开始的，然后连续逐个+1增长。

格式：数组名[索引];

1. 取值： System.out.println(arr [0] ); //0是编号第0个，结果是1

2. 赋值，修改数组的元素：

arr [2] = 100 //把编号为2的数值变为100

System.out.println(arr [2]); //输出编号为2的值，结果100

5.2.2 访问数组长度

System.out.println(arr length);

获取数组最大索引：System.out.println(arr length-1); //这样写前提要有内容，否则会报错

5.2.3 数组的遍历

遍历：即一个一个数据的访问。

1. 首先要访问数组的所有内容，代码为：

System.out.println(Arrays. to String(arr));

to String() ：是将数组转为字符串

注：

System.out.println(); 输出的是数组地址信息而不是内容

System.out.println(Arrays. to String(arr)); 才是内容

2. 输出数组内容：

格式：

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

完整的格式 如：要求输出三个年龄

题目2：

总结：

为什么要遍历数组：求和，元素搜索，找最大值，最小值
什么是遍历：一个一个的访问一遍容器中的数据，取出来（打印，求和，判断）
如何遍历数组：使用循环

5.3 数组的动态初始化

格式：数据类型 [ ] 数组名 = new数据类型 [ 长度 ]

默认值：

整数类型：0
小数类型：0.0
布尔类型：false
字符类型：'\u0000'
引用类型：null

5.4 数组的最值

5.5 数组排序

最常用：冒泡排序

六、方法

6.1 什么是方法

方法概述：

方法（method）是将具有独立功能的代码块组成为一个整体，使其具有特殊功能的代码集

方法的参数列表分为无参，有参，其中有参分为实参，形参。

注意事项：

方法必须先创建才可以使用，把一些代码打包在一起，该过程称为方法定义。
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用。

方法的完整格式：

修饰符 返回值类型 方法名(形参列表){
    方法体代码
    return返回值
}
//return下面不能再写代码，无意义，不会执行到

1. 有返回值：

public static int sum(int a,int b){
    int c = a+b;
    return c;
}

2. 无返回值：

public static void 方法名(){
    方法体（就是打包起来的代码）
}

public static void playGame(){
        System.out.println("开始");
        System.out.println("结束");

viod是无返回值类型
使用方法的好处

提高了代码的复用性，提高了开发效率。
让程序逻辑更清晰。

6.2 方法的定义和调用

6.2.1 无参

格式：方法名（） 例: isEvenNumber ();

6.2.2 有参

形参：全称形式参数，是指方法定义中的参数。

实参：全称实际参数，是指方法调用中的参数。

---形参和实参必须一一对应，否则会报错。

6.3 带返回值方法的定义和调用

方法的返回值就是方法运行的最终结果。

1. 方法调用格式：

数据类型变量名 = 方法名（参数）

//范例 
public static in getSum(int a,int b){
    int c = a+b;
    return c;
}

2. 带返回值方法的调用

直接调用：方法名（实参）;
复制调用：整数类型变量名 = 方法名（实参）; int a = sum (a:1,b:2);
输出调用：System.out.println(方法名(实参));

3. 有返回值方法中参数的运行过程

示例：

6.4 方法的重载

定义：方法的重载，Overlo所谓救所谓救就是多个方法相同，参数列表不同。

解决问题：对于功能类似的方法而言，方法名称太多，会导致繁琐，所以有了重载的概念。

示例：定义比较两个数字是否相同.

方法重载的多样性

哪些情况会发生重载：

参数的类型不同
多个类型的参数顺序不同
参数个数不同
不可以通过方法的返回值来判断方法是否发生重载（方法的重载）

七、面向对象

7.1 类和对象

7.1.1 什么是对象

什么是对象：客观存在的事物皆为对象(实体)
什么是面向对象：我们面向的事物（我们关注的事物信息）
什么是类：具有相似内部状态和运动规律的实体的集合（或统称为抽象）

什么是对象的属性；行为：

属性：是对象独有的特征，每个对象的属性都有特定的值。

行为：对象能够执行的操作。

类和对象的关系：

类是创建对象的模板。（类是对象的抽象，对象是类的实体）

面向对象有啥好处：

凡是找对象的编程套路，更加符合人类思维习惯，编程也会更直观。

7.1.2 类的定义

1. Javabean类（定义）：

格式：

public class 类名{
    //成员变量
    变量1的数据类型  变量1；
    变量2的数据类型  变量2；    
    ……
    //成员方法（可以编写0-n个方法）
    修饰符  返回值类型  方法名（参数）{
        执行语句；
    //注意：没有static
    }

}

2.测试类：

//创建对象 格式：
类名 对象名 = new 类名();   --------  class a = new class1();
//使用对象
//使用成员变量 格式：
对象名. 变量名;   ---------  a.name;
……
//使用成员方法 格式：
对象名. 方法名();  -------  a.show;

总结：

在Javabean类中，是不写main方法的，不作为运行
作为运行方法的叫做测试类
成员变量的完整定义格式是：

修饰符数据类型变量名称 = 初始化值；一般无需定义初始化只存在默认值。

不同数据类型的默认值：

7.2 成员变量和局部变量

有张表格就行了

成员变量：类中，但在方法外的变量，没有要求顺序
局部变量：方法中或方法声明上

7.3 对象的内存图解

示例：

7.4 类的封装

（三大特性之一：封装、继承、多态）

概述：是面向对称编程语言对客观世界的模拟，客观世界里的成员变量都隐藏在对象内部，外界无法操作。
如果不进行封装：那么对属性的操作，就具有可读可写能力，并且可写的值没有做任何规范性的约束，会造成数据的不安全。

封装原则：将类的某些信息隐藏在类的内部，通过成员变量private，提供对应的get变量名() 和 set变量名(参数) 方法。
封装的好处：通过方法来控制成员变量的操作，提高了代码的安全性。把代码用方法进行封装，提高了代码的复用性。

7.4.1 private关键字

概念：private关键字用于类中，作用是保护类中的成员变量或者成员方法的数据安全。

凡是被private修饰过后的成员变量或成员方法都不能直接被外界调用。需要先在类中进行数值的修饰才可以被外界调用。

7.4.2 this关键字

概念：用于指代成员变量，代表本类对象的引用。

什么时候用：当局部变量与成员变量同名时，this关键字可以指定控制台输出成员变量，而不输出局部变量

7.4.3 构造方法

概念：类的构造方法是一种特殊的方法，其名称必须与类名相同，它负责给对象中的成员进行初始化。

注意事项：

构造方法没有返回值类型。也不需要写返回值。
构造方法名称必须和类名保持一致。

public class Student {
    private String name;
    private int age;
    //构造方法
    public Student(){
        System.out.println("无参构造");
    }
    public void  show(){
        System.out.println(name + "："age);
    }
}

构造方法的重载：

带参构造方法和无参构造方法，两者方法名不同。但是参数不同，就叫构造方法重载。

7.4.4 访问控制修饰符

public、protected、默认default（不写）、private

修饰符	本类	同一个包中的类	子类	其他类
public	可以访问	可以访问	可以访问	可以访问
protected	可以访问	可以访问	可以访问	不能访问
默认	可以访问	可以访问	不能访问	不能访问
private	可以访问	不能访问	不能访问	不能访问

7.5 类的继承

未完待续……

链接到下一篇：http://t.csdnimg.cn/OUeD1

Domineering的薄荷

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java语言基础学习笔记

（1）什么是变量：如想改变一个值，让所有这个值都发生改变，就是变量。即：在程序运行过程中，其值可以发生改变的量。（2）变量定义：格式：数据类型变量名 = 变量值 int a = 10;如： int a = 10;//定义变量//输出变量由数字字母下划线“_”美元符号“$”组成，并且所有符号里不能有空格；不能以数字开头；不能是Java关键字或保留字；Java严格区分大小写，如：Class，C大写是符合规则的。方法。
复制链接

扫一扫