Java基础之复习笔记(上）

绝地灬酷狼 2024-04-20 14:28 73阅读 0赞

**目录**

一、Java是什么？

?Java概念

?Java运行机制

二、Java的语言基础

?关键字

?基本数据类型

?运算符

三、Java逻辑控制

?分支结构

?循环结构

四、Java的方法

?方法的定义

?方法的重载

?方法的递归

五.Java数组

?一维数组

?二维数组

六.类与对象

? 基础概念

?构造方法

?封装

七.代码块

?普通代码块

?构造块

?静态代码块

--------------------

> ?博主介绍：博客名为tq02，已学C语言、JavaSE，目前学了MySQL和JavaWeb
> 
> ?学习专栏： [ C语言][C] [JavaSE][] [MySQL基础][MySQL]
> 
> ?博主链接：[tq02的博客\_CSDN博客-C语言,Java,MySQL领域博主][tq02_CSDN_-C_Java_MySQL]
> 
> ⭐下章复习链接 ： [http://t.csdn.cn/Mz71o][http_t.csdn.cn_Mz71o]

## 一、Java是什么？ ##

### ?Java概念 ###

> Java是一门优秀的程序设计语言，是C语言基础之上更深一步的面向对象编程语言，拥有很多特性：简单性、面向对象性、分布性、稳健性、安全性、可移植性、多线程性等等，而Java不仅是一种编程语言，还是一种程序发布平台，可以分为：**JavaEE、JavaSE和JavaME**

Java 是拥有一套完整性系统学习的技术，而Java基础是重中之重，俗话说的好，只有基础打牢，万米高楼平地起。

public class  类名{
        public static void main(String[] args) {
            //程序代码
        }
    }

Java程序的执行入口是main()方法，一般存在于public class类中，并且main()函数必须存在于class当中，而一个Java文件只能有一个public class，public class默认为主类，并且Java文件名字必须和主类相同。

### ?Java运行机制 ###

> xxx.java的源文件先通过javac编译程序把源文件进行编译，编译后生成的.class文件是由字节码组成的平台无关、面向JVM的文件。最后启动**java虚拟机（JVM）**来运行.class文件，此时JVM会将字节码转换成平台能够理解的形式来运行。
> 
> 结论：Java程序运行需要经过编译、运行两个阶段。
> 
> 编译：Javac命令 运行：Java命令

![0be78e10530442a7866d741ee8b11aae.png][]

--------------------

## 二、Java的语言基础 ##

> 每一种编程语言都拥有关键字、数据类型和运算符，关键字为Java语言本身提供的一种特殊的标识符，数据类型是规定变量的类型。数据类型分为基本数据类型、引用数据类型。

### ?关键字 ###

![cef0017797cb49e6a2a4980a49634cce.png][]

关键字有50个，以上是主要的关键字

--------------------

### ?基本数据类型 ###

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td style="width:144px;">数据类型</td> 
   <td style="width:165px;">类型名</td> 
   <td style="width:190px;">类型大小及其描述</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">int</td> 
   <td style="width:165px;">整形</td> 
   <td style="width:190px;">4个字节</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">long</td> 
   <td style="width:165px;">长整形</td> 
   <td style="width:190px;">8个字节</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">short</td> 
   <td style="width:165px;">短整型</td> 
   <td style="width:190px;">2个字节</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">double</td> 
   <td style="width:165px;">双精度浮点型</td> 
   <td style="width:190px;">8个字节，但内存布局不同</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">float</td> 
   <td style="width:165px;">单精度浮点型</td> 
   <td style="width:190px;">4个字节，<span style="background-color:#ffd900;">取值：数+F</span>&nbsp;内存布局不同</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">char</td> 
   <td style="width:165px;">字符类型</td> 
   <td style="width:190px;">2个字节，使用：<span style="background-color:#ffd900;">单引号 + 单个字母</span></td> 
  </tr> 
  <tr> 
   <td style="width:144px;">byte</td> 
   <td style="width:165px;">字节类型</td> 
   <td style="width:190px;">1个字节</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">boolean</td> 
   <td style="width:165px;">布尔类型</td> 
   <td style="width:190px;">由JVM实现而不同，占一个字节或1比特位</td> 
  </tr> 
  <tr> 
   <td style="width:144px;">String</td> 
   <td style="width:165px;">字符串类型</td> 
   <td style="width:190px;">由字符组成，大小不确定。</td> 
  </tr> 
 </tbody> 
</table>

在运算符当中，特别关注float和double的内存存储方式，学习链接：[http://t.csdn.cn/tTo64][http_t.csdn.cn_tTo64]

--------------------

### ?运算符 ###

任何语言都缺少不了计算、比较、判断等操作，而进行这些操作基于运算符而实现。

![91302d1e6dbb4b12b0f00072c4d79f2f.png][]

运算符也有大小分，也就是优先级的顺序。

--------------------

## 三、Java逻辑控制 ##

逻辑控制语句分为顺序结构、分支结构和循环结构。

*  顺序结构比较简单，从上到下运行。
 *  分支结构：从上到下运行，但是中途有分路，需要选择路径向下运行
 *  循环结构：代码运行在一定的区域里循环运行，直到false跳出循环

### ?分支结构 ###

**分支结构有2种语法结构：if语法 和 switch语法**

**if语法**

>  **基本语法1**：if(布尔表达式)\{
> 
> //条件为true时，执行
> 
> \}

> **基本语法2**：if(布尔表达式)\{
> 
> //条件为true时，执行
> 
> \}else\{
> 
> //条件为false时，执行
> 
> \}

> **基本语法3：**if(布尔表达式)\{  
> //条件满足时执行代码  
> \}**else if**(布尔表达式)\{  
> //条件满足时执行代码  
> \}else\{  
> //条件都不满足时执行代码  
> \}

**switch语法**

> **基本语法**：switch(整数|枚举|字符|字符串)\{  
> case 内容1 : \{  
> 内容满足时执行语句;  
> \[break;\]  
> \}  
> case 内容2 : \{  
> 内容满足时执行语句;  
> \[break;\]  
> \}  
> ........ ........... .......... .............. ............ ......  
> default:\{  
> 内容都不满足时执行语句;  
> \[break;\]  
> \}  
> \}
> 
> **注**：如果没有break，当符合其中一个内容时，还会再次执行下面的语句

### ?循环结构 ###

循环语句有2种语法：while、for、do while。而配合循环语句使用的有break、contain

**break**：跳出循环。  **contain**:停止本次循环，重新循环

**while语句**

> **基础语法**：while(循环条件)\{  
> 循环语句;  
> \}
> 
> 当满足循环条件，则循环，不满足则不循环。可在循环语句当中使用 if语句，指定某个条件满足时使用break或者contain

**for语句**

> **基础语法1**：for(表达式1;表达式2;表达式3)\{  
> 循环体;  
> \}
> 
>  *  表达式1: 用于初始化循环变量
>  *  表达式2: 循环条件
>  *  表达式3: 设置循环变量的更改
> 
> 当满足循环条件，则循环，不满足则不循环。可在循环语句当中使用 if语句，指定某个条件满足时使用break或者contain
> 
> --------------------
> 
> **基础语法2：for(数据类型 变量名：数组）**
> 
>  **\{ 循环体 ； \}**
> 
> 变量名会遍历数组，并且每次循环，变量名会存储对应的数组值

**do while语句**

> **基础语法**：do\{  
> 循环语句;  
> \}while(循环条件);
> 
> 可先执行循环语句，再判断循环条件

## 四、Java的方法 ##

Java的方法类似于C语言的函数，而使用方法可以使代码被重复利用，使代码更好理解。

### ?方法的定义 ###

> **基本语法**： public static 方法返回值 方法名称（\[参数类型 形参 ...\])\{  
> 方法体代码;  
> \[return 返回值\];  
> \}
> 
> **调用语法：**数据类型 变量名 = 方法名称.( 实参);
> 
> --------------------
> 
> 注：
> 
>  *  执行是main()方法，而main()方法是静态方法，只能调用静态方法，所以使用static，将该方法设为静态方法。
>  *  如果不使用static，那么只能通过对象调用
>  *  调用时**不需要返回数据**，则方法返回类型是void，无返回值。
>  *  对于**基础类型**来说, 形参相当于实参的拷贝. 即 传值调用
>  *  对于**引用类型**来说, 形参相当于实参的拷贝. 即 传址调用

### ?方法的重载 ###

> 方法的重载：相同的函数名，不同的形参列表和返回值类型

代码示例：

class Test {
        public static void main(String[] args) {
                int ret1 = add(2, 3);
                double ret2 = add(2.5, 3.5);    
                double ret3 = add(2.5, 3.5,4.5);
    
    public static int add(int x, int y) {
    return x + y;
    }
    public static double add(double x, double y) {
    return x + y;
    }
    public static double add(double x, double y, double z) {
    return x + y + z;
    }
    }

### ?方法的递归 ###

一个方法在执行过程中调用自身, 就称为 "递归"

//求总和
    public static int sum(int num) {
        if (num == 1) {
        return 1;
        }
        return num + sum(num - 1);
    }

--------------------

## 五.Java数组 ##

数组就相当于一个容器，存放**相同类型**数据的容器，数组的学习主要是一维数组和二维数组。

### ?一维数组 ###

> **创建语法：**
> 
>  *  动态初始化  
>     **数据类型\[ \] 数组名称 = new 数据类型 \[ \] \{ 初始化数据 \};**
>  *  静态初始化  
>     **数据类型\[ \] 数组名称 = \{ 初始化数据 \};**

**数组使用：**

1.  使用 **数组名.length** 能够获取到数组的长度
2.  使用 \[ \] 按下标取数组元素. 需要注意, 下标从 0 开始计数
3.  使用 \[ \] 操作既能读取数据, 也能修改数据.
4.  不可以超出有效范围\[0, length - 1\]，不然会出现异常
5.  只能存储相同类型的数据
6.  在使用方法时，若传递的是数组，则进行的是传址调用

**数组转换字符串**

> 语法格式：**String str1=Arrays.toSting( 数组名）;**

**数组拷贝**

> 语法格式1：
> 
>  **数据类型\[ \] newArr = Arrays.copyOf(数组名, 拷贝长度);** 
> 
> 语法格式2：
> 
>  **数据类型\[ \] newArr = Arrays.copyOfRange(数组名, 下标值front，下标值after);** 
> 
> **//拷贝范围 下标值front-after**

--------------------

### ?二维数组 ###

> 概念：存放多个一维数组的容器
> 
> 语法格式：**数据类型 \[ \]\[ \] 数组名称 = new 数据类型 \[行数\]\[列数\] \{ 初始化数据 \};  
> 行**：代表几个一维数组  **列**：代表一维数组的范围大小

![58f6f4409e804dc09580726bd12f3e07.png][]

而至于三维数组、四维数组也是相同的道理，但出现的频率少得可怜。

--------------------

## 六.类与对象 ##

### ? 基础概念 ###

> 类与对象之间的关系：类是设计图、而对象是根据设计图具体化出来的实例
> 
> **基本语法：**
> 
>     //创建类
>     class <class_name>{
>             field;//成员属性
>             method;//成员方法
>     }
>     // 实例化对象
>     <class_name> <对象名> = new <class_name>();
> 
> **class**为定义类的关键字，ClassName为类的名字，\{\}中为类的主体。  
> 类中的元素称为：成员属性。类中的函数称为：成员方法。

注：在类中的方法不需要static，此时此刻，实例化出来的对象，是可以直接调用该方法的

### ?构造方法 ###

> 构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作  
> 语法规则：
> 
>  *  方法名称必须与类名称相同
>  *  构造方法没有返回值类型声明
>  *  每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
> 
> 注：**this关键字使用，以此修改当前的成员属性**

代码实例：

class Person {
        private String name;//实例成员变量
        private int age;
    
    //默认构造函数 构造对象
        public Person() {
           this.name = "caocao";
           this.age = 10;
    }
    //带有3个参数的构造函数
    public Person(String name,int age,String sex) {
            this.name = name;
            this.age = age;
    }
    
    public class Main{
        public static void main(String[] args) {
         Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
         Person p2 = new Person("zhangfei",80,);//调用带有2个参数的构造函数
        }
    }

### ?封装 ###

实例化出来的对象权利很大，可以改变成员属性的值，因此为了防止这种情况的出现，我们会使用private封装，从而，类的调用者无法使用。

class Person {
            private String name = "张三";
            private int age = 18;
            public void show() {
        System.out.println("我叫" + name + ", 今年" + age + "岁");
        }
    }
    class Test {
        public static void main(String[] args) {
            Person person = new Person();
            person.show();
        }
    }

**注：**private 不光能修饰字段, 也能修饰方法，当没有使用priavte修饰时，默认为使用public

--------------------

> 问：那么如果想要修改封装好的成员属性呢？
> 
> 答：使用getter和setter方法，以及this关键字
> 
> 使用this.属性名= " 新值 "；

代码示例：

class Person {
            private String name;//实例成员变量
            private int age;
    
            public void setName(String name){
            //name = name;//不能这样写
            this.name = name;//this引用，表示调用该方法的对象
        }
            public String getName(){
            return name;
        }
    
    }
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("caocao");
        String name = person.getName();
        System.out.println(name);
    }

注：

*  getName 即为 getter 方法, 表示获取这个成员的值.
 *  setName 即为 setter 方法, 表示设置这个成员的值.

## 七.代码块 ##

概念：使用 \{ \} 定义的一段代码

而根据代码块定义的位置以及关键字，我们可以分为以下三种：

*  普通代码块
 *  构造块
 *  静态块

### ?普通代码块 ###

直接定义在方法中。在代码块中的变量，作用域只存在代码块中。

代码示例：

public class Main{
        public static void main(String[] args) {
            {     //直接使用{}定义，普通方法块
                int x = 10 ;
                System.out.println("x1 = " +x);
            }
         int x = 100 ;
         System.out.println("x2 = " +x);
    }
    }
    // 执行结果
    x1 = 10
    x2 = 100

### ?构造块 ###

定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量  
代码示例：

class Person{
        private String name;//实例成员变量
        private int age;
        public Person() {
        System.out.println("I am Person init()!");
        }
        //实例代码块
        {
        this.name = "tq02";
        this.age = 22;
        System.out.println("I am instance init()!");
        }
    public void show(){
        System.out.println("name: "+name+" age: "+age);
    }
    }
    public class Main {
    public static void main(String[] args) {
    Person p1 = new Person();
        p1.show();
    }
    }
    
    // 运行结果
    I am instance init()!
    I am Person init()!
    name: bit age: 12 sex: man

### ?静态代码块 ###

使用static定义的代码块。一般用于初始化静态成员属性。并且只能访问静态数据成员

代码实例：

class Person{
        private static String name;//实例成员变量
        private int age;
        public Person() {
        System.out.println("I am Person init()!");
        }
        //实例代码块
        static {
        name = "tq02";
        System.out.println("I am instance init()!");
        }
    public void show(){
        System.out.println("name: "+name+" age: "+age);
    }
    }
    public class Main {
    public static void main(String[] args) {
    Person p1 = new Person();
        p1.show();
    }
    }

注：

*  静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
 *  静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行

--------------------

文章幅度太长，决定分为2部分，以上部分较为简单，容易理解。

\---------------懒惰的tq02

[C]: http://t.csdn.cn/3A5e9
[JavaSE]: http://t.csdn.cn/TBH4P
[MySQL]: http://t.csdn.cn/2FRvG
[tq02_CSDN_-C_Java_MySQL]: https://blog.csdn.net/m0_74097410?type=blog
[http_t.csdn.cn_Mz71o]: http://t.csdn.cn/Mz71o
[0be78e10530442a7866d741ee8b11aae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/3245f4ad4597470d94b29ad19cc8f84a.png
[cef0017797cb49e6a2a4980a49634cce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b7c1e6127e674b658735b58bc76a1fb1.png
[http_t.csdn.cn_tTo64]: http://t.csdn.cn/tTo64
[91302d1e6dbb4b12b0f00072c4d79f2f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/acb52b1c26664256b999bda9ac909585.png
[58f6f4409e804dc09580726bd12f3e07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/eac4e0aa06da40b3b84e63165b00d3ba.png