Java基础语法总复习

前言：

对于Java基础语法部分目前就告一段落啦，系列文章目录是之前写过的部分笔记，当然，这些目录中只涉及了我初学时认为应当总结概括的或者知识点较多的章节，对于此篇文章中未细细考究的内容大家可以由系列文章中细细解读。

对于整个JAVA基础语法部分来说，今天，查漏补缺，将这部分的重难点重新梳理一下。

万丈高楼平地起，要打好地基，加油加油鸭！！！

系列文章目录

Java基础——数据类型

Java基础——数据类型转换与运算符

Java中的类和对象

Java面向对象编程之多态

Java基础——彻底掌握String类

Java中的异常处理机制

Java中的内部类

---

文章目录

一、Java数据类型

1.数据类型

2.类型转换

3.运算符

二、程序逻辑结构 

三、方法的使用 

1.形参&实参

2.方法重载（overload)与方法重写(override)

3.Math类中的常用方法

4.构造方法 

四、数组的定义与使用

五、面向对象编程

1.Java中的类和对象_敲敲敲-CSDN博客

2.封装性——保护与易用

（1）访问修饰符

（2）代码块：

（3）this关键字

（4）匿名对象 

（5）包 package

3.继承

extends

super关键字

4. Java面向对象编程之多态_敲敲敲-CSDN博客

六、三大特殊类

 1.Java基础——彻底掌握String类_敲敲敲-CSDN博客

2.Object类

（1）最高父类

（2）toString方法

（3）equals方法

3.包装类

（1）八大基本数据类型——>包装类

（2）拆装箱

（3）String类和包装类的互转

七、 Java中的异常处理机制_敲敲敲-CSDN博客​​​​​​

八、  Java中的内部类_敲敲敲-CSDN博客

九、泛型 

1.泛型的产生

2.示例 

3.泛型接口

---

一、Java数据类型

1.数据类型

一个字节占8位 1byte = 8 bit

1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.

如int型占4个字节，32位，存储范围为 -2^31 ~ 2^31-1（因为最高位是标志位，表示正负）

（1）八大基本数据类型：

整型（默认值为0）：byte(1字节）、short(2字节）、int(4字节）、long(8字节）

浮点型（默认值为0.0）：单精度float（4字节）、双精度double(8字节）

字符型（默认值为 \u0000 表现为空格）：char(2字节） unicode编码 可与int型相互转化

    public static void main(String[] args) {
        char a = '1';
        int b = a;
        int c = a - '0';
        System.out.println(b);
        System.out.println(c);
    }

运行结果：

49
1 

布尔型（默认值为false):boolean

（2）引用数据类型：默认值为null,如数组、类、接口都是引用数据类型，引用数据类型存储的都是地址，所以记住，比较引用数据类型是否相等，要用equals方法，而不能直接用 == 号

【注意】Java中的数据类型都有默认值，但是在方法中定义的局部变量必须赋值后才能使用；

               final关键字修饰的常量，也必须在声明时赋值

2.类型转换

（1）小类型——>大类型 自动类型转换

byte这里有个小特殊：byte + byte JVM内部会自动将byte提升为int，所以：

byte a = 10   byte b = 6  byte c = a + b 会编译报错！！！

如果希望结果仍为byte型，还需要进行强制类型转换 byte c = (byte)(a + b )

（2）大类型——>小类型 强制类型转换，可能丢失精度

（3）拓展一点：int 和 String 类型的互转

    public static void main(String[] args) {
        String a = "12345";
        int b = 6;
//        String ——> int
//        Integer.parseInt()方法
        int c = Integer.parseInt(a);
        System.out.println(c);

//        int ——> String
//        str += 拼接
        String d ="";
        d += b;
        System.out.println(d);
//    String.valueOf()方法
        String e = String.valueOf(b);
        System.out.println(b);
    }

 3.运算符

常见的这里不再赘述，只重新复习几个易忘的

逻辑运算符：

&& 逻辑与

|| 逻辑非

！ 取反

位运算符——二进制运算

& 按位与 只有都为1才为1，否则为0

| 按位或 只有都为0才为0，否则为1

^ 按位异或 同为0，异为1

~ 按位取反 

 【注意】对于位运算符这里，我记得有一道典型应用，一组数据，每个数都出现了两次，只有一个数只出现了一次，请找出这个数

这道题就可以使用异或，让所有数全部异或一遍，异或的最后结果就是那个数

移位运算符——也是二进制运算

<< 左移 将二进制右侧补0，删除最左侧 相当于乘2

>> 右移 将二进制左侧补0，删除最右侧 相当于除以2

>>> 无符号右移

二、程序逻辑结构 

顺序结构:最基础的，单线程下一行行向下

分支结构：

(1)

if……else

if……else if……else……

注意与if……if……的区别

(2)switch(整型、字符型、字符串、枚举）{

case 1: ……break

case 2:……break

default:……break

}

【注意】如果没有break语句，执行完该case语句后，程序会继续执行剩下的case程序

如下面这道题：

下面的方法，当输入为2的时候返回值是多少？ ( )

 A:0  B:2  C:4  D:10

【答案】10

因为没有break语句

当i为2的时候，程序直接走到case 2这一行当中，result = 0+4;但是没有break.程序会继续执行到3处，result = 4+6=10;最后执行结束！

循环结构：

（1）for( ; ; ){ } 

（2）for-each for( : ){ }

（3）while(){ }

可以与break\continue搭配使用

break:结束循环

continue:跳出这次循环，继续下次循环 

三、方法的使用 

1.形参&实参

方法定义时的参数称为 "形参", 方法调用时的参数称为 "实参"

Java方法中的参数传递只有值传递，将实参的值复制一份给形参

如：

class Test { 
public static void main(String[] args) {
int a = 10; 
int b = 20; 
swap(a, b); 
System.out.println("a = " + a + " b = " + b); 
}
 public static void swap(int x, int y) { 
 int tmp = x;
 x = y;
 y = tmp; 
}
}

输出结果：a = 10 b = 20

并没有达到交换a,b值得结果 

2.方法重载（overload)与方法重写(override)

方法重载：方法名相同，参数个数或类型不同（与返回值无关）

方法重写：一般是子类覆写父类的同名方法

3.Math类中的常用方法

Math.max()

Math,min()

Math.abs(num) ——num的绝对值

Math.pow(a,b) ——a的b次方

Math.sqrt(num) ——根号num

4.构造方法 

用于执行对象的初始化，无返回值声明，方法名与类名相同

无显式声明构造方法，则JVM内部默认生成一个无参构造；

有显式声明构造方法后无论有无参数，JVM都不再生成默认的构造

构造方法可以重载

构造方法的调用，用this(参数）调用，且必须放在第一句，注意不是this.方法，直接是this(参数）

private修饰的构造方法，不能直接通过类外部产生对象，外部只能使用不能创造（如这种场景：星期类只有7个对象）

四、数组的定义与使用

1.数组——存放相同数据类型的一个集合

数组是引用数据类型，存储该数组的首地址，

2.创建方式：

静态初始化：

int[ ] a = {1,3,5};

动态初始化：

int[ ] a = new int[3]; //默认值为0

int[ ] a = new int[ ] {1,4,5,6}; 

3. 数组的遍历：

fori（从前向后遍历）

for-each(只能遍历，不能修改）

4.数组——>字符串

Arrays.toString(arr)

5.数组的拷贝（深拷贝）

Arrays.copyOf(arr,arr.length)

Arrays.copyOfRange(arr,2,4) 左闭右开

深拷贝：创建了新的数组对象，并将原来的数据复制到新对象中

浅拷贝：只是原对象的一个新引用，并未创建新对象

6.数组排序

Arrays.sort(arr) 双轴快速排序

7.二维数组 

int[ ] [ ] arr = new int[m] [n ]; m行n列

【注】数组这里有好多诸如排序、重新排列、判断有序性等问题，要多加练习，编写代码

五、面向对象编程

1.Java中的类和对象_敲敲敲-CSDN博客

在这一篇章中，主要理解类与对象的概念，为了更好的理解对象，在这里，我们引入了static关键字，注意static关键字的使用

2.封装性——保护与易用

（1）访问修饰符

public 公有的

protected 保护的，仅在本类以及子类中可见

default 默认的，同一个包下可见（不包含子包）

private 私有的，仅本类中可见，一般属性均为私有的，取得/设置该属性，需要定义该属性的setter /getter方法，通过方法调用获得属性

【注意】private不能修饰外部类，static也不能修饰外部类

（2）代码块：

普通代码块：方法内用{}的代码块

构造代码块：定义在类中，不加任何修饰符修饰——每产生一个对象，就执行该代码块一次，且执行次序优于构造函数 

静态代码块：定义在类中，static修饰——类加载时被执行，但只执行一次，且是最优先执行的，主方法所在的类有静态代码块，优于主方法执行，静态代码块可用于给静态变量赋值

class B1{
    public B1(){
        System.out.println("1");
    }
    {
        System.out.println("2");
    }
    static {
        System.out.println("3");
    }
}
public class D extends B1{
    public D(){
        System.out.println("4");
    }
    {
        System.out.println("5");
    }
    static {
        System.out.println("6");
    }

    public static void main(String[] args) {
        System.out.println("7");
        new D();
        new D();
        System.out.println("8");
    }
}

执行结果为：

3
6
7
2
1
5
4
2
1
5
4
8 

（3）this关键字

this 表示当前对象的引用，如作为额返回值，return this

this.属性 直接从本类中找属性

this.方法 调用本类方法

（4）匿名对象 

如Person类，new Person().age 

该对象无任何指向

Java中，当一个对象无任何指向时，会被标记为垃圾空间，使用过后会自动释放该内存空间

（5）包 package

相当于目录文件夹，可有效解决类名重复的问题

定义包： package 包名

导入包：import 包名.* 

              import 包名.类名

静态导入：import static Java.util.Arrays.*       导入该包中某个类的静态域

3.继承

extends

• 子类 extends 父类     子类继承父类的public和protected
• 不允许多重继承，只允许单继承（允许多层继承）

super关键字

• 在子类中使用super关键字调用父类的属性和方法
• super.父类属性
• super.父类普通方法
• super调用父类构造方法 ——super(参数列表）
• 子类构造方法，第一句一定是super(参数/无参)，因为子类构造必须先调用父类构造

4. Java面向对象编程之多态_敲敲敲-CSDN博客

多态这一章节参考标题这一章 ，主要明白向上转型、向下转型，方法覆写，抽象方法，抽象类以及接口，这一章还有final关键字的使用

六、三大特殊类

 1.Java基础——彻底掌握String类_敲敲敲-CSDN博客

String类这一章，参考标题这一篇，这一章，重点理解以下：

创建字符串的三种方式；

字符串也是引用数据类型，理解其内存布局；

掌握常量池的意义所在；

理解字符串的不可变性

学会应用StringBuilder类和StringBuffer类以及这两类与String类的互转，还有JDK内置的常用方法的使用

2.Object类

（1）最高父类

• Object类是所有类的默认父类，所以所有类都可以向上转型为Object类；
• Object类不仅是所有类的父类，只要是引用数据类型，包括数组、接口，也都可以向上转型为Object类

看下面这段代码：

    public static void main(String[] args) {
//        A是我们自定义的一个类
        Object o1 = new A();
//        数组
        int[] a = new int[3];
        Object o2 = a;
    }

编译并没有出错，这段代码我们就是将其他数据类型向上转型为Object类

（2）toString方法

System.out.printlin()方法默认调用的是Object类的toString方法，而如果我们想打印输出自定义类的对象的属性，就需要覆写toString方法，toString方法的返回值即为我们输出的内容，如果不覆写，输出的可能是对象地址

示例：

public class test {
    public static void main(String[] args) {
        Person p1 = new Person("笑笑",10);
        System.out.println(p1);
    }

}
class Person{
    String name;
    int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
//   覆写toSring方法
    public String toString(){
        return "name = " + name + " age = " + age;
    }
}

 运行结果：

name = 笑笑 age = 10

（3）equals方法

与toString方法类似，如果需要比较属性值是否相等，我们也需要覆写equals方法，否则默认比较的就是地址

示例：（接上例中的Person类）

//    覆写equals方法
    public boolean equals(Object o){
//        如果为空
        if(o == null) return false;
//        如果就是该对象自己
        if(o == this) return true;
//        如果不是同一类型的
        if(!(o instanceof Person)) return false;
//        否则，强转，并比较
        Person p = (Person) o;
        return this.name.equals(p.name) && this.age == p.age;
    }

3.包装类

（1）八大基本数据类型——>包装类

将八大基本数据类型封装为类，因为Object类并不能接收基本数据类型，故而，将八大基本数据类型包装为类，便于部分操作

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

其中，Boolean类，Character类是对象型包装类，是Object的直接子类；

其余是数值型包装类，是Number类的子类

【注意】：包装类的默认值变成了null.不再是原来的数值，同时，包装类比较大小也是要用equals方法

（2）拆装箱

装箱：基本数据类型 ——>包装类

拆箱：包装类对象中的数值——>基本数据类型

JDK提供自动拆装箱，所以其实 包装类和基本数据类型 一样

示例：

    public static void main(String[] args) {
        int a = 10;
        Integer b = 3;
        a += b;
        System.out.println(a);
    }

a、b分别是基本数据类型和包装类，但可以正常一起加减

（3）String类和包装类的互转

• String -> 包装类            如：Integer.parseInt(str)
• 包装类->String              如：String.valueOf(a)

示例：

    public static void main(String[] args) {
        Integer a = 17;
        String b = "123";
//        Integer->String
        String c = String.valueOf(a);
//        String->Integer
        Integer d = Integer.parseInt(b);
        System.out.println(c);
        System.out.println(d);
    }

 七、 Java中的异常处理机制_敲敲敲-CSDN博客​​​​​​

有关异常这一章节：

核心是 try-catch-finally的使用，以及throw-throws的理解与掌握

理解异常对象抛出的调用链

熟悉异常以西，了解常见的异常

八、  Java中的内部类_敲敲敲-CSDN博客

成员内部类

静态内部类

方法内部类

匿名内部类

九、泛型 

1.泛型的产生

• 在类定义时并不确实具体数据类型，而是在创建对象时再进行类型的定义，拓展了类的数据类型的广度
• 编译期即可检查类型是否正确；
• 一般用单个的大写字母代替具体数据类型

2.示例 

//K、V即为泛型，在具体创建对象时，可以定义他们为任意数据类型
public class test {
    K key;
    V value;
}

class X{
//    如创建该类型对象时，K为整型，V为字符型
    test t = new test<>();
}

如若没有泛型，我们想达到类似的效果，可能需要用Object类定义，然后创建对象时再进行强制类型转换，可能会报错，但是用泛型就很好的避免了这一问题并且在编译期就已经进行了检查

3.泛型接口

子类在实现泛型接口时，是可以选择的，要么继续保留泛型，要么定义子类时明确数据类型

最后，好啦，终于，将基础语法部分从前向后梳理了一遍，还是又发现了好多小细节以及易忘的知识点的，要好好复习吖！对于这里的关键字部分，从前向后梳理可能还是容易不明晰，后续再将关键字列出来重新总结一篇好啦。