Java基础学习

最新推荐文章于 2025-05-05 18:46:07 发布

小茗同学zZ

最新推荐文章于 2025-05-05 18:46:07 发布

阅读量105

点赞数

文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_33485630/article/details/129624401

版权

Java基础

关键字

Java所有的关键字都在这个图里面（都是小写编辑器里面会变色）

Java所有组成部分都需要名字、类名、变量名以及方法名都被称为标志符

用于定义数据类型的关键字(11个：class interface byte short int long float double char boolean void

用于定义流程控制的关键字（11个：if else switch case default while do for break continue return

用于定义访问权限修饰符的关键字（3个：private protected public

用于定义类，函数，变量修饰符的关键字（4个:abstract final static synchronized

用于定义类与类之间的关系的关键字（2个:extends implements

用于定义建立实例及引用实例，判断实例的关键字（4个:new this super instanceof

用于异常处理的关键字（5个:try catch finally throw throws

用于包的关键字（2个:package import

其他关键字(8个:

native strictfp transient volatile assert

goto const enum

true false null 不是关键字,是值，虽然它们也会变色

八大数据类型

float知识点

char知识点

类型转换

变量

类变量：在类里面方法外面，变量前面加上static。这个类里面所有的方法都可以调用

实例变量：在类里面方法外面。调用时需要初始化类后才能调用

局部变量：在方法里面。在方法中变量定义后可随处调用

常量

final:同过final修饰过的类不能改变值所以不能被继承

public class HelloWorld {
    // 静态常量
    public static final double PI = 3.14;
    // 声明成员常量
    final int y = 10;
    public static void main(String[] args) {
        // 声明局部常量
        final double x = 3.3;
    }
}

自增自减运算符

逻辑运算符

基本内置类型

int-->Integer

byte-->Byte

short-->Short

long-->Long

float-->Float

double-->Double

char-->Character

1、byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持）都可以用于switch语句。

2、long、float、double、boolean四种基本类型以及它们的包装类（在Java所有版本中）都不能用于switch语句。

3、enum类型，即枚举类型可以用于switch语句，但是要在Java5.0（1.5）版本以上才支持。

4、所有类型的对象（包括String类，但在Java5.0/1.5以上版本中，该项要排除byte、char、short、int四种基本类型对应的包装类）都不能用于switch语句。

Java引用类型

引用类型分析

关于深入理解java的引用类型：

在java中，引用类型可以分为两大类：值类型，引用类型。

其中值类型就是基本数据类型，如int，double类型，而引用类型就是除了基本数据类型之外的所有类型（如class类型），所有的类型在内存中都会分匹配一定的空间，包括形参，而形参在方法调用完成后被分配的那块内存就会被取消，基本的变量类型的储存空间被分配到栈中，而引用类型有两块储存空间。

一块在栈中，一块在堆中，那么在java中当函数调用的时候到底是传值还是传引用？

记住Java没有指针，只有引用。

什么是引用

简单的说，引用其实就像是一个对象的名字或者别名 (alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似 C++ 语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。

如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间（stack，栈空间）来保存。但是它们的值是相同的，都指示同一个对象在内存（heap，堆空间）的中位置。比如：

通过上面的代码和图形示例不难看出，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 "This is a Text!"。但要注意String 对象的值本身是不可更改的 (像 b = "World"; b = a; 这种情况不是改变了 "World" 这一对象的值，而是改变了它的引用 b 的值使之指向了另一个 String 对象 a)。

如图，开始b 的值为绿线所指向的“Word Two”，然后 b=a; 使 b 指向了红线所指向的”Word“.

引用注意点

引用是一种数据类型（保存在stack栈中），保存了对象在内存（heap，堆空间）中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)；

不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。

对象如何传递的

那么对象（记住在Java中一切皆对象，无论是int a;还是String a;，这两个变量a都是对象）在传递的时候究竟是按什么方式传递的呢？其答案就只能是：即是按值传递也是按引用传递，但通常基本数据类型（如int,double等）我们认为其是“值传递”，而自定义数据类型（class）我们认为其是“引用传递”。

Java流程控制

for循环 while循环 do-continue的使用

方法的使用

方法的重载

public void funs(){}
public void funs(int i){}
public void funs(String str){}
public void funs(String... str){}

递归

递归就是：A方法调用A方法！就是自己调用自己

递归结构包括两个部分：

递归头：叶么时候不调用自身方法。如果没有头，将陷入死循环。

递归体：什么时候需要调用自身方法。

数组

数组在堆栈表现形式

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

1.静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

// 静态初始化

int[] iStaticArr = { 5, 2, 0 };
LOLHero[] staticHeros = new Hero[] {
        new LOLHero("艾希","女"),  
        new LOLHero("盖伦","男"),  
        new LOLHero("挖掘机","未知")  
};

2.动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

//动态初始化
int[] iDynamicArr = new int[3];
iDynamicArr[0] = 5;
iDynamicArr[1] = 2;
iDynamicArr[2] = 0;
LOLHero[] dynamicHeros = new LOLHero[3];
dynamicHeros[0] = new LOLHero("艾希","女");
dynamicHeros[1] = new LOLHero("盖伦","男");
dynamicHeros[2] = new LOLHero("机器人","未知");

3.静态初始化

其实数组在动态初始化的时候，第一行代码int[] iDynamicArr = new int[3];就已经完成了静态初始化，一般整形数组默认初始值为0；

布尔数组默认初始值为 false；

String 数组以及对象数组初始值为 null.

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型,不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

多维数组

图解

Arrays工具类解析

Arrays.toString(数组)将数组一个个打印出来

Arrays.sort(数组)数组排序

Arrays.fill(数组，（重载参数包括从几到几），填充的值)数组填充

冒泡排序

面向对象

什么是面向对象

面向对象的本质为：以类的方式组织代码，以对象的组织（封装）数据

三大特性：

封装

继承

多态

构造器

解释

和类名相同

没有返回值

作用

new本质在调用构造方法

初始化对象的值

注意点

定义有参构造之后，如果使用无参构造，显示的定义一个无参的构造

快捷键：Alt+Insert

创建对象内存分析

jdk7之前方法区在堆中，8以后移动到本地内存了

//存放于栈中，new一个相当于在堆中创建一个实例类，然后这个实例类里面的属性方法都从方法区拿到
Person person = new Person();

类中就包含两块：

静态的属性属性

动态的行为方法

属性：就是类中的字段也称为成员变量

默认初始化：

数字：0 浮点，小数 0.0

char:u0000

boolean:false

所有的引用类型（String，对象）：null

封装

提高程序的安全性，保护数据

隐藏代码的实现细节

统一的接口

增加系统可维护性

特点：属性私有，get/set

继承

extends 的意思是扩展。子类是父类的扩展

Java中类只有单继承，没有多继承。

一个父类（基类）可以有多个子类（派生类）

子类继承父类，会拥有父类的全部公有的（public）方法和属性。私有（private）的不会被继承

ctrl+h:打开继承树查看类的继承关系。

在Java中所有的类都默认直接或间接继承Object类

super

super:访问父类属性

this：调用当前类

super注意点

super调用父类的构造方法，必须在构造方法的第一个

super必须只能出现在子类的方法或者构造方法中

super和this不能同时调用构造方法

this与super的区别

代表的对象不同：this 本身调用者对象，super 代表父类对象的引用

使用前提不同：this 没有继承也可以使用，super只能在继承条件下使用

构造方法的不同：this()调用本类的构造方法，super()调用父类的构造。且不能同时在同一方法中，因为优先级关系。

重写

父类非静态的方法才叫重写

重写：不再同一类，都是方法的重写，和属性无关

重载：是同一类里，方法名相同，参数类型不同。

重写是子父类间，子类重写父类的方法，alt+insert或者Ctrl+O，方法名相同，方法内容不同。前提是父类使用public方式，且不使用static方式。

重写：产生于父类和子类之间，是指子类将父类的方法进行重写

重载：是指同一个类中，可以因不同的参数类型，参数个数等可以写出多个相同名字的方法

重写：需要有继承关系，子类重写父类的方法！

1．方法名必须相同

2．参数列表列表必须相同

3．修饰符：范围可以扩大但不能缩小：public>Protected>Default>private

4．抛出的异常：范围，可以被缩小，但不能扩大； ClassNotFoundException --> Exception(大）

重写，子类的方法和父类必要一致；方法体不同！

为什么需要重写：子类的方法替换父类的方法，所以要用子类new父类才生效

1．父类的功能，子类不一定需要，或者不一定满足！

快捷键：Alt + Insert ；或者Ctrl+O override；

即b是A new出来的对象，因此调用了A的方法

因为静态方法是类的方法，而非静态是对象的方法

有static时，b调用了B类的方法，因为b是用b类定义的

没有static时，b调用的是对象的方法，而b是用A类new的

static修饰的方法归类所有，叫类的成员，不叫对象的成员

父类一个方法可以让多个子类重写。子类重写了父类的方法，执行了子类的方法

多态

子类能调用的方法都是自己的或者继承父类的！

父类可以指向子类，但不能调用子类特有的方法

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型（父类或有关系的类）有很多

对象能执行那些方法，主要看对象左边的类型，和右边的关系不大

多态注意事项：

多态是方法的多态，属性没有多态。类中属性是静态的方法是动态的

父类和子类要有联系，不然会出现类型转换异常。classCastException 列如String student=new Student()

存在条件：

两个类是继承关系。

方法需要重写

父类引用指向子类 Person Person = new Student();

不能被重写的修饰符

static 方法，属于类，它不属于实例

final 属于常量存在于常量池

private 方法私有的

instanceof和类型转换

 //可以理解为左边引用类型与右边创建类型连接为一条线,线上的都是同一类型,不在线上的就不是
        //看=的   编译是否通过看=左边的类型，实际判断对象变为=右边的类型。

        //应该是："x instanceof Y"取决于X是否与Y有继承关系，且类X是实例x的引用类型
        //System.out.println(x instanceof  y);

        Object object = new Student();
        System.out.println(object instanceof  Object);//true
        System.out.println(object instanceof  Person);//true
        System.out.println(object instanceof  Student);//true
        System.out.println(object instanceof  Teacher);//false
        System.out.println(object instanceof  String);//false
        System.out.println("======================");

        //总结：编译，看左边；运行，看右边。
        Person person=new Student();
        System.out.println(person instanceof  Object);//true
        System.out.println(person instanceof  Person);//true
        System.out.println(person instanceof  Student);//true
        System.out.println(person instanceof  Teacher);//false
        //System.out.println(person instanceof  String);//编译不通过
        System.out.println("======================");

        Student student=new Student();
        System.out.println(student instanceof  Object);//true
        System.out.println(student instanceof  Person);//true
        System.out.println(student instanceof  Student);//true
        //System.out.println(student instanceof  Teacher);//编译不通过
        //System.out.println(student instanceof  String);//编译不通过

父类与子类的转换

//父想要转子，则需要重新开辟只属于子的空间，则需用强制转换
//  父转子: 向下转型, 强制转, 丢失父类被子类所重写掉的方法。
Person person1=new Person();
Student student1= (Student) person1;
student1.AttendClass();//person类可以调用学生类特有的AttendClass方法。

//低（子）转高（父）时，由于子已经继承了父的所有，所以删去属于自己的后自然而然就可以转化问父类的；
//子转父: 向上转型, 直接转, 丢失子类中原本可直接调用的特有方法；
Student student2=new Student();
Person person2=student2;
//person2.AttendClass(); //学生类中有个特有的AttendClass方法调用不到

静态类static

从类一起创造，所以在静态类中可以调用静态常量，在类非静态方法中可以直接调用静态类

//静态导入包
import static java.lang.Math.random;
//System.out.println(random());
import static java.lang.Math.PI;
public class StaticCode {
    //2 赋初始值
    {
        System.out.println("匿名代码块");
    }
    //1 静态代码块类初始化只调用一次，
    static {
        System.out.println("静态代码块");
    }
    //3
    public StaticCode() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        StaticCode staticCode = new StaticCode();
        //4
        System.out.println("主方法");

        //1.匿名代码块 2.构造方法
        StaticCode staticCode1 = new StaticCode();
    }
}

抽象类abstract

extends:继承的缺席单继承没办法继承多个类。Java中类只有单继承没有多继承，但是接口（implements）可以多继承

抽象类特点：

不能new这个抽象类，只能靠子类去实现它；约束

抽象类中可以有正常的方法，抽象方法必须写在抽象类中

抽象类不能new出来，但是也存在构造器

抽象类和普通类的区别就是不能new对象然后可以包含抽象方法抽象方法必须被子类重写！

接口类interface implements

抽象类：abstract修饰类继承抽象类：extends

接口类：interface修饰类实现接口类：implements

接口类特点：

起到的约束作用

定义一个接口类可以让不同的类来实现，也可以一个类实现多个接口

接口不能被实例化（new）因为接口中没有构造方法，接口的实现类可以实例化

使用implements来实现接口，需要实现接口里面方法

内部类

内部类修饰符默认为private

public class Test {
	//内部类
    class innerClass{}
}

静态内部类

public class Test {
    public static void main(String[] args) {
        Test.innerClass
    }
    static class innerClass{

    }
}

匿名内部类

public class Test {
    public static void main(String[] args) {
        Test.innerClass
    }
   {
       System.out.println("hello");
    }
}

一个Java类中可以有多个class类，但只能有一个public class

没有名字初始化类，不用讲实例保存到变量中

局部内部类（写在方法中）

public class Test {
    public static void main(String[] args) {
        class innerClass{
            
        }
    }
}

异常

抛出异常

捕获异常

异常处理关键字：

try，catch，finally，throw，throws

快捷键 Ctrl+alt+t 添加异常代码块

public class test {
    public static void main(String[] args) {
        int a=10;
        int b =0;

        //快捷键 Ctrl+alt+t 添加异常代码块
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();//打印错误的栈信息
        } finally {
        }
        //多个catch捕获异常必须从小到大捕获
        try {//try 监控区域
            System.out.println(a/b);
        }catch (Exception e){//catch(异常类型)捕获异常  Throwable错误最高层级
            System.out.println("程序异常");
        }catch (Error e){
            System.out.println("程序错误");
        }catch (Throwable e){
            System.out.println("最高异常捕获");
        }finally {//最后都会执行下面的代码  比如关闭IO，资源
            System.out.println("结束输出");
        }

        //调用者捕获异常
        try {
            new test().doThrows();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //测试抛出异常
    //throws 这个方法中处理不了这抛出，让调用这个方法的人来处理
   public void doThrows() throws Exception{
       System.out.println(1/0);

           throw new ArithmeticException();//throw主动抛出异常 ，一般在方法中使用

   }
}