Z1d10tのBlog

A note for myself,have fun!

JAVA基础

Z1d10t's Avatar 2023-09-25 知识学习

分享本文
  1. 1. IDEA
    1. 1.1. 创建项目前置知识
    2. 1.2. project和module的关系
    3. 1.3. 集成JVM
  2. 2. 基本语法
    1. 2.1. JAVA标识符
    2. 2.2. JAVA修饰符
    3. 2.3. JAVA变量
    4. 2.4. JAVA数组
    5. 2.5. JAVA关键字
    6. 2.6. 从HelloWorld开始
    7. 2.7. public class 和 class的区别
    8. 2.8. 注释
  3. 3. JAVA对象和类
    1. 3.1. 构造方法
    2. 3.2. 创建对象
    3. 3.3. 访问实例变量和方法
    4. 3.4. import导包
    5. 3.5. 基本数据类型
      1. 3.5.1. 内置数据类型
      2. 3.5.2. 引用类型
    6. 3.6. 常量
    7. 3.7. 自动类型转换
  4. 4. JAVA变量类型
    1. 4.1. 参数变量
    2. 4.2. 类变量（静态变量）
  5. 5. JAVA修饰符
    1. 5.1. 访问控制修饰符
      1. 5.1.1. 默认访问修饰符default
      2. 5.1.2. 私有访问修饰符private
      3. 5.1.3. 公有访问修饰符public
      4. 5.1.4. 受保护的访问修饰符protected
      5. 5.1.5. 访问控制和继承
    2. 5.2. 非访问修饰符
      1. 5.2.1. static修饰符
      2. 5.2.2. final修饰符
      3. 5.2.3. abstract修饰符
      4. 5.2.4. synchronized 修饰符
      5. 5.2.5. transient修饰符
      6. 5.2.6. volatile修饰符
  6. 6. JAVA运算符
  7. 7. JAVA循环结构
    1. 7.1. while
    2. 7.2. do…while循环
    3. 7.3. for
    4. 7.4. JAVA增强for循环
    5. 7.5. continue和break
  8. 8. JAVA条件语句
  9. 9. JAVA数组
    1. 9.1. 声明数组变量
    2. 9.2. 创建数组
    3. 9.3. 实例
    4. 9.4. for-each循环
    5. 9.5. 多维数组
    6. 9.6. 初始化
  10. 10. JAVA正则

JAVA基础

IDEA

感觉正式java之旅之前还是要先稍微了解IDEA的基本知识，不然很难进行下去。

创建项目前置知识

IDEA中最大的单位应该是project

img

可以理解为是workspace

然后是directory、module和package

package是JAVA类的命名空间 避免类名重复

加入我们创建com.Z1d10t 那么就会在本地创建嵌套的文件

img

这两个层级应该是一样的都是低于project 但是有些差异

module一般是我们用于构建源代码的文件夹，用于组织项目的不同部分

而directory是普通文件夹 就比如我们在电脑上普通的文件夹 没有特殊含义

在项目中常常用来放静态音视频图片之类的

然后我们就可以右击我们的module开始创建源文件进行创作了

img

project和module的关系

img

集成JVM

如果我们不用IDEA进行java开发的话，我们首先是创建.java的源代码，然后通过javac.exe来编译为.class后缀的文件才可以运行

img

但是IDEA直接集成了JAVA虚拟机也就是JVM，直接写完帮我们编译然后运行，非常方便。

这也就是为什么java有跨平台性，编译一次到处执行

就是因为JVM的原因，不用去看机器环境，自己就有一个环境，把自己包裹起来的呢种。

img

基本语法

编写 Java 程序时，应注意以下几点：

  • 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
  • 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass，也就是要驼峰式命名。
  • 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
  • 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
  • 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

JAVA标识符

通俗说就是名字，类名变量名方法名都被称为标识符

  • 字母数字美元符号或者下划线开头其他非法
  • 关键字不能作为标识符 关键字就是一些已经被java占用的名字 有特殊含义的我们不能用
  • 大小写敏感

JAVA修饰符

  • 访问控制修饰符 : default, public , protected, private
  • 非访问控制修饰符 : final, abstract, static, synchronized

可以用来修饰类中方法和属性

JAVA变量

  • 局部变量
  • 类变量（静态变量）
  • 成员变量（非静态变量）

JAVA数组

数组是储存在堆上的对象，可以保存多个同类型变量

JAVA关键字

https://www.runoob.com/java/java-basic-syntax.html 遇到了直接查表就行了

从HelloWorld开始

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

img

首先就是要需要梳理一个理念就是在java中一切都是类

psvm快捷键可以直接生成 public static void main(String[] args){}

sout快捷键可以直接生成System.out.println("hello world")

首先我们的文件名是什么那么我们的类名也是什么

img

public class 和 class的区别

也就是说我们可以创建多个类

img

但是公共类只能有一个并且公共类的类名必须与文件名保持一致

并且任何类中都可以设置程序入口 也就是都可以写main方法

但是虽然我们可以在一个java源文件中定义多个类，但是这种做法是不规范的，比较规范的是一个源文件只能定义一个class

注释

1
2
//单行注释
/**/多行注释

img

JAVA对象和类

构造方法

如果没有显式构造方法 java编译器会为该类提供一个默认构造方法

一个类构造方法可以有多个

img

创建对象

1
2
3
4
5
6
7
8
9
10
11
public class Student {
    public Student(String name){
        System.out.println("这是一个学生名为"+name);

    }

    public static void main(String[] args) {
        Student stu = new Student("byd");

    }
}

访问实例变量和方法

1
2
3
4
5
6
/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

eg:

1
2
3
4
5
6
7
8
9
10
11
public class Student {
    public String LZG= "byd";
    public Student(String name){
        System.out.println("这是一个学生名为"+name);
    }

    public static void main(String[] args) {
        Student stu = new Student("byd");
        System.out.println(stu.LZG);
    }
}

img

import导包

首先在Z1d10t相对路径还有一个learn package

内容如下

img

然后我们导入到Z1d10t package中

img

然后调用 可见可以正常输出

基本数据类型

有内置数据类型和引用数据类型

内置数据类型

用到了直接查

https://www.runoob.com/java/java-basic-datatypes.html

引用类型

  • 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
  • 对象、数组都是引用数据类型。
  • 所有引用类型的默认值都是null。
  • 一个引用变量可以用来引用任何与之兼容的类型。
  • 例子：Student stu = new Student("byd");

常量

在程序运行时是不能修改的

在java中是用final来修饰变量的

1
final double PI = 3.1415927;

img

自动类型转换

img

小转大可以 但是大转小需要强制转换并且还会损失精度

JAVA变量类型

变量类型:

  • 局部变量（Local Variables）：定义在方法、构造方法或语句块中的变量，作用域只限于当前方法、构造方法或语句块中。局部变量必须在使用前声明，并且不能被访问修饰符修饰。
  • 成员变量（Instance Variables）：定义在类中、方法之外的变量，作用域为整个类，可以被类中的任何方法、构造方法和语句块访问。成员变量可以被访问修饰符修饰。
  • 静态变量（Class Variables）：定义在类中、方法之外的变量，并且使用 static 关键字修饰，作用域为整个类，可以被类中的任何方法、构造方法和语句块访问，静态变量的值在程序运行期间只有一个副本。静态变量可以被访问修饰符修饰。
  • 参数变量（Parameters）：方法定义时声明的变量，作为调用该方法时传递给方法的值。参数变量的作用域只限于方法内部 简单说就是函数用于传值的形参

参数变量

省流：形参

有两个点：

  • 值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。
  • 引用传递：在方法调用时，传递的是实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。

类变量（静态变量）

java中静态变量是属于类的，而不是对象的实例

由于静态变量是与类相关的，因此可以通过类名来访问静态变量，也可以通过实例名来访问静态变量

img

JAVA修饰符

访问控制修饰符

直接用一张图片来看访问权限关系

img

默认访问修饰符default

默认访问修饰符的访问级别是包级别（package-level），即只能被同一包中的其他类访问

img

私有访问修饰符private

外部无法直接访问到 只能通过本类的public函数间接去访问

img

可见直接访问是会报错的

公有访问修饰符public

很常见就不说了 总之就是门户大开

受保护的访问修饰符protected

  • 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问
  • 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法

一般很少用 我在这里就不多说了

访问控制和继承

  • 父类中声明为 public 的方法在子类中也必须为 public。
  • 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
  • 父类中声明为 private 的方法，不能够被子类继承。

非访问修饰符

static修饰符

  • 静态变量：static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
  • 静态方法：static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问

final修饰符

变量一旦赋值后，不能被重新赋值

final 修饰符通常和 static 修饰符一起使用来创建类常量

但是如果不用static那么就要用非静态函数才能调用 也就是不用static修饰的 不然会报错

img

可见无法被改变

img

abstract修饰符

一个类不能同时被final和abstract修饰

如果类包含抽象函数那么这个类一定要申明为抽象类 不然会报错

img

抽象类可以包含抽象方法和非抽象方法

抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供

如果有主体会报错

img

抽象方法由其子类实现

img

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问

transient修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

1
2
public transient int limit = 55;   // 不会持久化
public int b; // 持久化

volatile修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

JAVA运算符

大致和其他语言差不多 就不过多赘述了

JAVA循环结构

while

1
2
3
while( 布尔表达式 ) {
  //循环内容
}

img

do…while循环

1
2
3
do {
       //代码语句
}while(布尔表达式);

此结构会在判断条件是否成立之前执行一次 所以这个结构至少执行一次

img

for

1
2
3
for(初始化; 布尔表达式; 更新) {
    //代码语句
}

img

JAVA增强for循环

1
2
3
4
for(声明语句 : 表达式)
{
   //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

img

continue和break

和其他语言利用一样 不多说

JAVA条件语句

same

JAVA数组

声明数组变量

两种方式但是一般推荐第一种方式 

1
2
3
4
5
dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

创建数组

1
arrayRefVar = new dataType[arraySize];

做了两件事情:

  1. 首先用new dataType[arraySize];创建了一个数组
  2. 然后将其赋值给arrayRefVar

必须先声明然后再创建 如果不声明就创建会报错

img

实例

下标依然是从0开始

img

for-each循环

其实就是之前我们讲过的循环结构的增强for循环

img

多维数组

初始化

直接为每一维分配空间 这种我们用的最多也最方便

或者是一维一维分配空间

1
type[][] typeName = new type[typeLength1][typeLength2];

img

JAVA正则

规则什么的都和其他语言差不多

看个例子

img

首先要引入依赖

然后要分别创建两个类:Pattern和Matcher

Pattern是要进行的匹配模式的对象

Matcher是被匹配内容的对象

其次还有一个点就是在java正则模式中转义要用//其他语言我们都是只用一个/

本文最后更新于 天前，文中所描述的信息可能已发生改变

本文发表于 

知识学习