JavaSE语法总结

一个隐藏的大佬

已于 2023-04-12 21:53:23 修改

阅读量137

点赞数 2

分类专栏： Java # JavaSE 文章标签： jvm java 面试

于 2023-04-12 21:47:57 首次发布

本文链接：https://blog.csdn.net/smnha/article/details/130117451

版权

Java 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

JavaSE

3 篇文章 0 订阅

订阅专栏

JavaSE语法总结

1. 前言

我们在学完一个东西之后，一定要做总结，因为只有学会总结，你才会发现自己原来已经学了这么多东西，那这些东西你是否都掌握了呢？那就要看你有么有学会总结了。把每一章最重要的点给写下来，方便自己复习，也方便别人来参考，一举多得的事情，所以希望大家都能学会总结。把自己会的东西都给写下来。

2.认识Java

Java之父

在前面学习Java的时候，我们认识到詹姆斯·高斯林老爷子，也就是Java之父，真的是非常厉害阿！学习Java的小伙伴来一起认识认识这位老爷子吧！

安装JDK

大家还记得就是在一开始，要写Java代码的时候，是不是要安装一个叫做JDK的东西，这玩意就是我们运行Java的工具，如果不装他，你是运行不了Java代码的。有多少人还记得JDK，JVM，JRE这些东西阿！比如我现在问你这三者有什么关系，你们能一下子回答上来吗？

他们三者的关系：

JDK：Java开发包工具
JRE：Java运行环境
JVM：Java虚拟机
你只要安装了JDK，JDK里面就会有JRE和JVM这两个东西，具体看下面这个图

3.数据类型

还记得我们Java里面有哪些数据类型吗？学到现在不会还有小伙伴们不知道吧！

Java里面分两种类型：一个是基本数据类型，一个是引用数据类型。

基本数据类型

数据类型	包装类	占字节数
byte	Byte	1
short	Short	2
int	Integer	4
long	Long	8
float	Float	4
double	Double	8
char	Character	2
boolean	Boolean	Java里面没说

引用数据类型

数据类型
数组
String
枚举
自定义类

4.运算符

运算符我们学过很多个阿！在C语言里面已经见得不少了，但是在Java里面，我们又学到了几个新的运算符和一些新的规则：

运算符	功能
右移运算符(>>)	一个数的二进制往右移动n位，移动完成之后，会在左边补0或者是补1，这是要看符号位，如果是正数，则补0，如果是复数，则补1。
左移运算符(<<)	一个数的二进制往左移动n位，移动完成之后，会在右边补0。
(无符号右移)>>>	一个数的二进制往右移动n位，移动完成之后，会在左边补0。这个符号，无论你是正数还是负数，通通只会补0。
&& \|\|	Java里面没有1是真，0是假的这种概念了，所以你不能在这两个符号左右两边写个0或1，这两个符号，左右两边必须是布尔表达式。

5.程序的逻辑控制

判断条件

在Java里面，只要是涉及到判断条件，括号里面一定是一个布尔表达式，不能跟C语言一样，在括号里面写个1或者写个0，这样代码是编译不通过的。

//这样的代码编译一定会报错，是无法通过的error
public static void main(String[]){
    /*if(1){
        System.out.println(true);
    }else{
        System.out.println(false);
    }error*/
    //正确写法
    if(1 == 1){
        System.out.println(true);
    }else{
        System.out.println(false);
    }
}

面试题

在Java里面也有if，switch，for，while，do while这些语句，其中最特殊的就是switch语句了，这里面会有一道面试题，他会问你switch的括号里面哪些数据类型能放，哪些不能放。

switch里面可以放的数据类型有：char，byte，short，int，String，enum(枚举)
switch里面不可以放的数据类型有：long，float，double，boolean

6.方法的使用

如何定义一个方法

权限访问修饰符 (静态关键字) 返回值类型 方法名(){
    语句;
}
public static void fun1(){
    
}

可变长参数

在Java里面引入了一个新的概念叫做可变长参数，比如说我要做很多数的加法，我总不能一个个的去定义变量对吧！这个时候就可以用到可变长参数：

public class Test {

    //两个数字的加法
    public static int add(int a, int b) {
        return a + b;
    }

    //三个数字的加法
    public static int add(int a, int b, int c) {
        return a + b + c;
    }

    //如果要做很多数的加法怎么办呢？我猜同学们一下子就会想到数组
//    public static int add(int[] arr) {
//        int sum = 0;
//        for (int i = 0; i < arr.length; i++) {
//            sum = sum + arr[i];
//        }
//        return sum;
//    }

    /**
     * 在Java中引入了可变长参数的概念，我们来看看这究竟是什么东西，当我把这个东西
     * 定义出来之后，你会发现上面那个参数是数组的方法报错了，这是为什么呢？我们知道
     * 方法的重载参数列表必须是不一样的，既然报错了，那是不是就说明这个可变长参数，
     * 其实本质上就是数组呢？其实就是这样的。其实就是一个数组。但是用起来会比数组
     * 更方便一点。
     */
	//可变长参数写法：类型... 变量名; 只能是三个点阿！不能是n个点
    public static int add(int... arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum;
    }

    public static void main(String[] args) {
        //两个参数
        int ret1 = add(1, 2);
        System.out.println(ret1);

        //三个参数
        int ret2 = add(1, 2, 3);
        System.out.println(ret2);

        //多个参数，数组写法
        //int ret3 = add(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
        //System.out.println(ret3);

        //多个参数，可变长参数写法,会比数组写起来更方便一点
        int ret4 = add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(ret4);
    }
}

什么是重载

重载的特点：

方法名必须相同。
方法参数类型，顺序，个数必须不同。
与方法返回值无关。
不一定在同一类里才能发生重载，不在同一个类里，继承关系下也能发生重载。

什么是重写

重写的特点：

方法名必须相同。
方法参数类型，顺序，个数必须相同。
返回值没有特殊情况必须一样，特殊情况如果父类和子类构成协变类型的话，返回值就可以不一样。
不能重写private，static，final所修饰的方法。
子类重写的方法的访问权限必须大于等于父类。

面试题

面试官问你重写和重载的区别是什么，你是不是就可以把上面这几点说给他听。

7.数组的使用

数组的概念

在Java里面数组也是一个引用类型。

如何定义一个数组

public static void main(String[] args){
    //三种创建方式
    int[] arr1 = new int[10];
    int[] arr2 = {1,2,3,4,5,6,7,8};
    int[] arr3 = new int[]{1,2,3,4,5,6,7,8};
}

如何遍历一个数组

public static void main(String[] args) {
    //三种方式
    int[] arr1 = new int[10];
    int[] arr2 = {1, 2, 3, 4, 5, 6, 7, 8};
    int[] arr3 = new int[]{1, 2, 3, 4, 5, 6, 7, 8};

    //1.for循环
    for (int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
    }
    System.out.println("=============================");
    //2.for-each增强型for循环
    for (int x : arr2) {
        System.out.println(x);
    }
    System.out.println("=============================");
    //3.Arrays工具类里面的toString方法
    System.out.println(Arrays.toString(arr3));
}

数组可以当作为返回类型

在Java里面可以返回一个数组了，可以将数组作为返回值了，我记得在C语言里面是做不到的。

public class Test2 {

    //数组作为返回值
    public static int[] fun1() {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] ret = fun1();
        System.out.println(Arrays.toString(ret));
    }

}

二维数组

在Java里面二维数组其实是一种特殊的一维数组，他长什么样子的呢？

//二维数组的定义，遍历什么的我就不写了，大家知道就行
public static void main(String[] args) {
    int[][] arr = {{1, 2, 3}, {4, 5, 6}};
}

8.类和对象

什么是类

类是描述一个对象的属性和行为的集合。

类里面有属性和方法：

属性分为两个：
- 普通成员属性：属于对象的属性，存放在对象当中，要想访问这个属性，必须先得有这个对象才行。
- 静态成员属性：属于类的属性，存放在方法区，想要访问这个属性，直接通过这个类就可以访问。
方法分为两个：
- 普通成员方法：属于对象的方法，想要调用这个方法，也必须得有这个对象才行。
- 静态成员方法：属于类的方法，想要调用这个方法，通过类去调用就可以访问到。

什么是对象

对象就是通过我们定义好的一个类，来构造出一个实体出来，类就像是一个模板，我们通过这样的模板，去实实在在创造一个实体出来，这就叫实例化对象。并且一个类可以实例化多个对象。

构造方法

方法名和类名相同，没有返回值。
作用：为了帮助我们的成员属性进行初始化。
- 就地初始化：public int age = 16;
- 默认初始化：就是什么值也不给，默认会有一个初始值。
当我们没有添加任何一个构造方法的时候，编译器会默认为我们添加一个无参的构造方法，如果我们自己写了构造方法，那么编译器就不再提供无参的构造方法了。
构造方法也可以发生重载。

this关键字

this是当前对象的应用。
this.data; 可以通过this来访问类里面的成员属性。
this.func(); 可以通过this来访问类里面的成员方法。
this(); 可以通过this来访问构造方法。但是必须是放在构造方法里的第一行，并且不能嵌套调用构造方法。
静态方法里面不能使用this关键字。

封装

封装是指我们有一些属性不想被你直接访问到，我们想隐藏这些细节，就会通过private来修饰我们的成员属性或者是成员方法，加上private关键词之后，被私有化的属性和方法，就只能在当前内里面使用，出了当前内就访问不到了，如果想要访问的话，可以写一些公开的接口，比如说get和set方法。就可以通过这些方法来间接的访问我们私有化的属性。

包的概念

包其实就是一个文件夹，不同的包里，可以存在两个同名的文件，包的作用就是为了方便我们更好的管理这些类。然后还记得导包用的是哪个关键字吗？import对不对，这个关键字要牢记阿！

访问修饰限定符

private：只能在当前类访问。
包访问权限(default)：只能在当前类或者是当前包中能访问。
protected：只能在当前类或者是当前包中能访问，或者是不同包下的子类，通过super关键字来访问。
public：哪里都可以访问得到。

static关键字

被static修饰的属性和方法，被称为静态属性和静态方法，他们不依赖于对象的，就是说不需要通过对象，也可以访问，只需要通过类名就可以调用静态属性和静态方法。并且在静态方法里面是不能调用非静态的属性和方法，因为非静态的属性和方法，是依赖于对象的，所以没有办法直接在静态方法里调用。

代码块

实例代码块

class Person{
    //实例代码块
    {
        
    }
}

静态代码块

class Person{
    //静态代码块
    static{
        
    }
}

局部代码块

这个几乎用不到，就不举例了。
同步代码块

这个以后会遇见的，到时候再讲吧！

当代码块和构造方法一起出现的时候，他们执行顺序是：先是静态代码块并且他只会执行一次，然后是实例代码块，然后是构造方法。

内部类

静态内部类

//静态内部类的定义
class Outter {
    static class Inner {

    }
}

public class Test2 {

    public static void main(String[] args) {
        //静态内部类实例化
        Outter.Inner inner = new Outter.Inner();
    }
}

非静态内部类

//非静态内部类的定义
class Outter2 {
    class Inner2 {

    }
}

public class Test2 {

    public static void main(String[] args) {
        //非静态内部类的的实例化
        Outter2 outter2 = new Outter2();
        Outter2.Inner2 inner2 = outter2.new Inner2();
    }
}

匿名内部类

public static void main(String[] args) {
    //匿名内部类：没有名字的类，常用来实现接口
    new Runnable(){
        @Override
        public void run() {
            System.out.println("你好世界");
        }
    };
}

继承

大家思考一下为什么要有继承，继承是用来干什么的，继承就是为了实现对我们的代码的复用，如果有两个类里面有同样的东西，我们就可以对这两个类进行一个共性的抽取，然后让这两个类，去继承另一个类，从而实现对代码的优化。

继承关键字

继承的关键字是extends，当子类继承父类的时候，子类会继承父类里不是static，final所修饰的成员属性和方法，并且Java是单继承，一个子类只能继承一个父类。

//当父类里面有属性和方法的时候，子类继承父类，子类也会拥有父类的属性和方法
class Animal{
    public String name;
    public int age;
    
    public void func(){
        
    }
}

class Dog extends Animal{
    
}

super关键字

super是用来指代父类的引用，他有哪几个作用，大家还记得吗？

super.data; 通过super来访问父类的成员属性
super.func(); 通过super来访问父类的成员方法
super(); 通过super来访问父类的构造方法，这个特性必须放在构造方法里的第一行，并且也不能嵌套调用。

面试题：面试官问你super和this的区别是什么，你什么就可以把以上这几点给他讲讲。

再谈代码块

如果父类和子类里面都有静态代码块，非静态代码块和构造方法的话，执行顺序是怎样的呢？

执行顺序是：父类的静态代码块，然后是子类的静态代码块，然后再是父类的非静态代码块和构造方法，最后是子类的非静态代码块和构造方法。

final关键字的使用

final所修饰的变量，就称为常量，因为他不可被修改。
final所修饰的方法，不能被重写。
final所修饰的类，不能被继承。

多态

多态就是给的东西不同，我能给你展现的功能就不一样，就像是一个电脑的USB接口，你插上U盘，他就可以给你自动读取里面的数据。插上键盘，就可以敲代码。我们正是需要这种思想来帮助我们简化代码。完成更多的功能。

多态的实现条件

在Java中要实现多态，必须满足以下条件：

必须要继承一个类。
子类必须重写父类的方法。
通过父类的引用来调用子类重写的方法。

多态里面最重要的就是重写了，如果子类没有重写父类的方法，没有体现出区别，那多态就没什么意义了。关于重写可以看看前面方法那块，这里就不做过多赘述了。

向上转型

还记得向上转型吗？就是通过父类去接收子类的实例，然后通过父类的引用调用子类重写父类里的方法，这就是向上转型，我们说向上转型是有缺点的，就是他只能访问父类自己的成员，不能访问子类的成员。

向下转型

我们之前说过向下转型很不安全，把一个大的东西，放到一个小的东西里面，肯定是有风险的，所以我们常常会搭配instanceOf关键字来一起使用，在使用前先检查检查，确定这个对象里面是我想要的对象，然后再通过这个对象去调用自己的方法。

9.抽象类和接口

抽象类

还记得抽象类的特点吗：

里面可以有抽象方法，也可以有普通方法。
不能被实例化。
子类继承了抽象类，必须要把抽象类里面的抽象方法给重写了。
类和方法都是被abstract所修饰。
抽象方法不能被private，static，final给修饰，因为抽象方法存在的意义就是被重写。你加上这些东西就不能重写了。
抽象方法没有方法体。
抽象类里面可以没有抽象方法，但是如果里面有抽象方法的，一定只能是存在抽象类里面。
虽然不能被实例化，但是可以发生向上转型。

以上这几点，你都记住了吗？

接口

还记得接口的特点吗：

成员属性默认是被public static final所修饰的。
成员方法默认是被public abstract所修饰的。
接口里面可以有default方法。
不能被实例化
实现接口的关键字是implements，当一个类实现这个接口的时候，必须重写里面的方法。
一个类可以实现多个接口。
接口里面可以有静态方法。

面试题：面试官问你接口和抽象类的区别是什么，你就可以把这上面几点说给他听。

10.String类的使用

我们说String这个类型声明出来的字符串是不可修改的，因为底层的value数组是被private所修饰的，所以我们拿不到这个value数组，所以也没有办法修改它，所以你对字符串的任何一个操作，什么toUpperCase，toLowerCase这些都是创建了一个新的字符串，并没有在原来的基础上做出改变。如果想要改变字符串里面原本内容，最好用StringBuilder和StringBuffer这两个类，因为这两个类的字符串可以被修改。面试官如果问你他们三个有什么区别，你怎么回答。

他们三者的区别：