2025年java 基础学习

大家好，我是讯享网，很高兴认识大家。

Java基础 关键字 Java所有的关键字都在这个图里面（都是小写编辑器里面会变色） ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 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 不是关键字,是值，虽然它们也会变色 八大数据类型 ![img](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/d788d43f8794a4c2d9c77d66754b18dcaf6e39db.jpeg) float知识点 char知识点 类型转换 变量 类变量：在类里面方法外面，变量前面加上static。这个类里面所有的方法都可以调用 实例变量：在类里面方法外面。调用时需要初始化类后才能调用 局部变量：在方法里面。在方法中变量定义后可随处调用 ![在这里插入图片描述](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/.png) 常量 final:同过final修饰过的类不能改变值所以不能被继承 ```java 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; } } ``` 自增自减运算符 ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 逻辑运算符 ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 基本内置类型 + 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类型），所有的类型在内存中都会分匹配一定的空间，包括形参，而形参在方法调用完成后被分配的那块内存就会被取消，基本的变量类型的储存空间被分配到栈中，而引用类型有两块储存空间。 ![img](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/--.png) 一块在栈中，一块在堆中，那么在java中当函数调用的时候到底是传值还是传引用？ 记住Java没有指针，只有引用。 什么是引用 + 简单的说，引用其实就像是一个对象的名字或者别名 (alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似 C++ 语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。 + 如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间（stack，栈空间）来保存。但是它们的值是相同的，都指示同一个对象在内存（heap，堆空间）的中位置。比如： ![img](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/--.png) 通过上面的代码和图形示例不难看出，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 "This is a Text!"。但要注意String 对象的值本身是不可更改的 (像 b = "World"; b = a; 这种情况不是改变了 "World" 这一对象的值，而是改变了它的引用 b 的值使之指向了另一个 String 对象 a)。 ![img](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/--.png) 如图，开始b 的值为绿线所指向的“Word Two”，然后 b=a; 使 b 指向了红线所指向的”Word“. 引用注意点 * 引用是一种数据类型（保存在stack栈中），保存了对象在内存（heap，堆空间）中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)； * 不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。 对象如何传递的 + 那么对象（记住在Java中一切皆对象，无论是int a;还是String a;，这两个变量a都是对象）在传递的时候究竟是按什么方式传递的呢？其答案就只能是：即是按值传递也是按引用传递，但通常基本数据类型（如int,double等）我们认为其是“值传递”，而自定义数据类型（class）我们认为其是“引用传递”。 Java流程控制 for循环 while循环 do-continue的使用 方法的使用 方法的重载 ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) ```java public void funs(){} public void funs(int i){} public void funs(String str){} public void funs(String... str){} ``` 递归 递归就是：A方法调用A方法！就是自己调用自己 递归结构包括两个部分： 递归头：叶么时候不调用自身方法。如果没有头，将陷入死循环。 递归体：什么时候需要调用自身方法。 ![image-](imageimage-.png) 数组 - 数组在堆栈表现形式 + 数组的默认初始化 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。 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. + 数组的四个基本特点 1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。 2. 其元素必须是相同类型,不允许出现混合类型。 3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。 4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 5. 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。 + 多维数组 图解 + Arrays工具类解析 1. Arrays.toString(数组)将数组一个个打印出来 2. Arrays.sort(数组)数组排序 3. Arrays.fill(数组，（重载参数包括从几到几），填充的值)数组填充 冒泡排序 面向对象 什么是面向对象 面向对象的本质为：<font style="color:red;">以类的方式组织代码，以对象的组织（封装）数据</font> 三大特性： 1. 封装 2. 继承 3. 多态 构造器 + 解释 1. 和类名相同 2. 没有返回值 + 作用 1. new本质在调用构造方法 2. 初始化对象的值 + 注意点 1. 定义有参构造之后，如果使用无参构造，显示的定义一个无参的构造 2. 快捷键：Alt+Insert ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 创建对象内存分析 ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) * jdk7之前方法区在堆中 ，8以后移动到本地内存了 ```java //存放于栈中，new一个相当于在堆中创建一个实例类，然后这个实例类里面的属性方法都从方法区拿到 Person person = new Person(); ``` 类中就包含两块： 1. 静态的属性 属性 2. 动态的行为 方法 属性：就是类中的字段 也称为成员变量  默认初始化：  数字：0 浮点，小数 0.0  char:u0000  boolean:false  所有的引用类型（String，对象）：null 封装 1. 提高程序的安全性，保护数据 2. 隐藏代码的实现细节 3. 统一的接口 4. 增加系统可维护性 特点：属性私有，get/set 继承 <font style="color:red;">extends</font>的意思是扩展。子类是父类的扩展 Java中类只有单继承，没有多继承。 一个父类（基类）可以有多个子类（派生类） 子类继承父类，会拥有父类的全部公有的（public）方法和属性。私有（private）的不会被继承 ctrl+h:打开继承树查看类的继承关系。 在Java中所有的类都默认直接或间接继承Object类 super super:访问父类属性 this：调用当前类 super注意点 1. super调用父类的构造方法，必须在构造方法的第一个 2. super必须只能出现在子类的方法或者构造方法中 3. super和this不能同时调用构造方法 this与super的区别 1. 代表的对象不同：this 本身调用者对象，super 代表父类对象的引用 2. 使用前提不同：this 没有继承也可以使用，super只能在继承条件下使用 3. 构造方法的不同：this()调用本类的构造方法，super()调用父类的构造。且不能同时在同一方法中，因为优先级关系。 重写 父类非静态的方法才叫重写 ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 重写：不再同一类，都是方法的重写，和属性无关 重载：是同一类里，方法名相同，参数类型不同。 重写是子父类间，子类重写父类的方法，alt+insert或者Ctrl+O，方法名相同，方法内容不同。前提是父类使用public方式，且不使用static方式。 重写：产生于父类和子类之间，是指子类将父类的方法进行重写 重载：是指同一个类中，可以因不同的参数类型，参数个数等可以写出多个相同名字的方法 重写：需要有继承关系，子类重写父类的方法！  1．方法名必须相同  2．参数列表列表必须相同  3．修饰符：范围可以扩大但不能缩小：public>Protected>Default>private  4．抛出的异常：范围，可以被缩小，但不能扩大； ClassNotFoundException --> Exception(大） 重写，子类的方法和父类必要一致；方法体不同！ 为什么需要重写：子类的方法替换父类的方法，所以要用子类new父类才生效  1．父类的功能，子类不一定需要，或者不一定满足！  快捷键：Alt + Insert ；或者Ctrl+O override； ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 即b是A new出来的对象，因此调用了A的方法 因为静态方法是类的方法，而非静态是对象的方法 有static时，b调用了B类的方法，因为b是用b类定义的 没有static时，b调用的是对象的方法，而b是用A类new的 static修饰的方法归类所有，叫类的成员，不叫对象的成员 父类一个方法可以让多个子类重写。子类重写了父类的方法，执行了子类的方法 多态 子类能调用的方法都是自己的或者继承父类的！ 父类可以指向子类，但不能调用子类特有的方法 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。 一个对象的实际类型是确定的，但可以指向对象的引用的类型（父类或有关系的类）有很多 对象能执行那些方法，主要看对象左边的类型，和右边的关系不大 多态注意事项： 1. 多态是方法的多态，属性没有多态。类中属性是静态的方法是动态的 2. 父类和子类要有联系，不然会出现类型转换异常。classCastException 列如String student=new Student() 3. 存在条件： 1. 两个类是继承关系。 2. 方法需要重写 3. 父类引用指向子类 Person Person = new Student(); 4. 不能被重写的修饰符 1. static 方法，属于类，它不属于实例 2. final 属于常量存在于常量池 3. private 方法 私有的 instanceof和类型转换 ```java //可以理解为左边引用类型与右边创建类型连接为一条线,线上的都是同一类型,不在线上的就不是 //看=的 编译是否通过看=左边的类型，实际判断对象变为=右边的类型。 //应该是："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);//编译不通过 ``` 父类与子类的转换 ```java //父想要转子，则需要重新开辟只属于子的空间，则需用强制转换 // 父转子: 向下转型, 强制转, 丢失父类被子类所重写掉的方法。 Person person1=new Person(); Student student1= (Student) person1; student1.AttendClass();//person类可以调用学生类特有的AttendClass方法。 //低（子）转高（父）时，由于子已经继承了父的所有，所以删去属于自己的后自然而然就可以转化问父类的； //子转父: 向上转型, 直接转, 丢失子类中原本可直接调用的特有方法； Student student2=new Student(); Person person2=student2; //person2.AttendClass(); //学生类中有个特有的AttendClass方法调用不到 ``` 静态类static 从类一起创造，所以在静态类中可以调用静态常量，在类非静态方法中可以直接调用静态类 ```java //静态导入包 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）可以多继承 抽象类特点： 1. 不能new这个抽象类，只能靠子类去实现它；约束 2. 抽象类中可以有正常的方法，抽象方法必须写在抽象类中 3. 抽象类不能new出来，但是也存在构造器 4. 抽象类和普通类的区别就是不能new对象 然后可以包含抽象方法 抽象方法必须被子类重写！ ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 接口类interface implements 抽象类：abstract修饰类 继承抽象类：extends 接口类：interface修饰类 实现接口类：implements ![image-](https://gitee.com/TheXMClassMate/markdownInsertPicture/raw/master/images/image-.png) 接口类特点： 1. 起到的约束作用 2. 定义一个接口类可以让不同的类来实现，也可以一个类实现多个接口 3. 接口不能被实例化（new）因为接口中没有构造方法，接口的实现类可以实例化 4. 使用implements来实现接口，需要实现接口里面方法 内部类 内部类修饰符默认为private ```java public class Test { //内部类 class innerClass{} } ``` + 静态内部类 ```java public class Test { public static void main(String[] args) { Test.innerClass } static class innerClass{ } } ``` + 匿名内部类 ```java public class Test { public static void main(String[] args) { Test.innerClass } { System.out.println("hello"); } } ``` 一个Java类中可以有多个class类，但只能有一个public class 没有名字初始化类，不用讲实例保存到变量中 + 局部内部类（写在方法中） ```java public class Test { public static void main(String[] args) { class innerClass{ } } } ``` * 异常 + 抛出异常 + 捕获异常 异常处理关键字： try，catch，finally，throw，throws 快捷键 Ctrl+alt+t 添加异常代码块 ```java 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主动抛出异常 ，一般在方法中使用 } } ``` ![异常分类](https://img-blog.csdn.net/?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VsdWFuc2hpMTI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

一键复制

编辑

原始数据

java 基础学习按行查看

相关推荐