Java基础

岳大博

已于 2022-05-15 12:27:04 修改

阅读量69

点赞数

分类专栏： java 文章标签： java intellij-idea 开发语言

于 2022-05-14 15:27:34 首次发布

本文链接：https://blog.csdn.net/qq_28613337/article/details/124707074

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Idea的使用

创建一个空项目
为空项目创建一个模块
为项目配置运行环境。project structure > SDK: 1.8.0; language level: 8

注释

单行注释 //
多行注释以 /开头
文档注释以/* 开头

基本数据类型（关键字）

整形

byte 一个字节8bits；所以最多表示 2^7个大小，最高一个位置用来表示正负数（-128, +127）
short 两个字节；16bits；所以最多表示2^15个大小，最高一个为正负（-32768, -32767）
long占8个字节；64bits；所以最多表示2^63大小
long 变量名 = 1000L
0x前缀表示，16进制；0开头的表示8进制

浮点类型

float占4个字节
double 变量名 = 1000.0F
double占8个字节
浮点数表示的范围是有限的，一般不用来做重要场景的比较。可能会存在误差

字符类型

char 2个字节；只能定义一个字符；可以使用单引号
char word = 'A';
默认采用unicode字符集；所以java中的字符可以使用(int)CharA来进行强转
char CharA = ‘\u0003’ // 表示unicode中的第三个字符；

布尔类型

boolean 只占一个位。

引用数据类型

类型转换

强制转换，可以实现从低到高的转换；（可能会产生内存溢出和精度损耗）
byte num = 127
自动转换，可以实现从高容量到低容量的转换；

变量

定义之后不能改变的值
方式或函数中定义的局部变量
定义在方法外，没有static 修饰的变量，实例属性；只能通过实例对象来调用；
定义在方法外，有static修改的变量，类变量；在方法中直接使用；

常量

定义之后不能改变的值；
使用 final 来修改

运算符

两个数值类型的数值进行计算时，如果类型中没有long类型，会按照int类型去计算。最后按照接受变量的类型进行转换；如果计算过程中数据出现内容溢出，可以先将其中一个变量的类型转换为高容量类型然后再进行计算；
b = a++ // 表示先将变量a赋值给b，然后再将a 自增；
a = b++ // 表示先将a 自增1, 再将变量a赋值给b；与 a++ 执行顺序不一样；
与 &&，或 || 非！
位运算，效率极高。2 << 2 等价于 *2 ； >> 2相当于 / 2;
如果运算符最左边为 String，那么后面的都会转为String，并进行随后的操作；如果最后一个为String，那么会先计算前面的最后对数字做String转换；
三元运算符； x? y: z；如果x为真，那么返回y,如果为假，那么返回z;

包机制

用于防止命名空间重复
想要引入其他包中的类，可以使用 import 关键字
包机制决定了，java只能在项目根目录执行及package所在的文件夹

代码执行

顺序执行
if条件执行；if else满足一个条件其他条件不会再执行；
switch case “A”: dongSomeThing(); default 满足其中一个条件，剩下的条件不管满足与否都执行；所以通常其后添加break关键字；
for (int i = 0, int j = 10; i < 10 && j > 0; i++, j--;) {} for中依次为遍历初始化;条件; 每次迭代执行语句；

数组

数组描述的相同类型的一组数据；按照先后次序排列
定义数组两种方式
int[] numArray = new int[10];  // 定义一个int类型的数组；int类型默认值为0；
int numArray2[] = new int[10];  // 另外一种方式；虽然没有给元素赋值，但是在该数组初始化的时候，数组中的元素也被初始化为了该类型的默认值；
int numArray2[] = {1, 2, 3, 4};  
numArray.length;  // 获取数组的长度
特点

长度确定
类型一致
元素类型可以是任意类型
数组在声明的时候，会在栈中记录下该变量，在初始化内容的时候会在堆开辟一个空间用来存储数据内容
数组遍历
for (int A: arrayA) {}
二维数组 int A[][]

类

重载

一个方法中可以有多个同名但参数不同（参数类型不同，数量不同）的方法；这样在调用的时候会根据传递参数的不同调用不同的方法；
编译器原理：会根据调用参数逐个与对应方法的形参进行对比，直到仅有一个满足条件；
命令行传参；在main方法中可以接受

对象

使用new关键字来实例化一个对象。
new 一个对象的过程：先调用默认的构造器接受一些参数初始化对象，之后返回构造的对象；

调用的没有完成的方法或创建的每一个对象，都会放在栈中。而栈中存储的仅仅是一个引用，该引用指向的内容存储在堆中。堆中有一个特别的区域是方法区，存储了每个类的内容（对象的模板）；方法区中有一个静态方法区，对象不用实例化可以直接调用；

构造器

和类名一样的方法，没有返回参数的类型
public class ObjectClassTest {
    public int age;
    public String name;

    public ObjectClassTest(int age, String name) {
        this.age = age;
        this.name = name;
    }
}
idea编辑器中，快捷键 Alt + Insert
类中定义的方法符合重载机制，所有一个类可以有多个参数不同的构造器
在方法中使用 this来操作类中的其他资源

方法

参数

参数如果是8大基本类型，那么传递的是值。如果是引用类型，那么传递的是引用；

可变长参数

在方法的参数的最后一个，可以在变量类型后面跟上 ... 来标记该参数；

封装

实例属性使用 public修饰的时候，对象可以直接调用。但是可能会存在随意修改的情况。一般会采用 private修改，使用get属性名 和 set属性名的方法来获取或设置属性；

继承

super用来调用父类的属性或方法
使用extends使当前类继承指定的类；会继承父类中所有public、default的方法和属性
在new 实例化的子类的时候会首先调用父类的构造器；再调用子类的构造器；super();只能写在第一行；

重写（public的方法）

子类中实现了父类中同名的方法
参数列表必须相同
方法命相同
修饰符范围可以扩大但不能缩小；public > Protected > Default > private
异常抛出的范围可以缩小但是不能扩大

静态方法/多态

使用static修饰的方法；
属于类的方法，判断被实例化的对象属于哪个类，通过对象前面的类型来决定。所以该对象调用哪个静态方法，决定于其属于哪个类，即该对象前面的类名；
实现条件

有父子继承
子类重写父类的方法
父类引用指向子类对象 Person persion1 = new Students()
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（修饰对象的类型）

类型转换

instanceof 是否可以进行引用类型的转换；obj instanceof ClassName 如果该对象是由ClassName类或者其父类实例化得到的那么返回true；证明二者可以进行转换或者强制转换；如果其仅仅对应修饰类和当前类存在关系，那么返回false，证明两者不能强制转换；如果以上两个条件都没有编译报错；
但是在基本类型中以上不适用。可能基本类型做了特殊处理；
子类转换为父类，可以直接转换（但是会损失一些子类中特有的方法）
父类转子类，需要在子类中创建子类中原来没有的方法，所以需要强行转换，强行给父类中添加方法；
属性没有多态

属性

静态属性 使用static修饰的属性；
非静态属性 没有使用static修饰的属性；
静态属于类，可以由类直接调用，一个类仅存储一份；非静态属于实例，必须由实例对象来调用
静态代码块单独使用 static修饰，在实例化对象的时候第一个执行，该类第一次实例化的时候执行一次；单例模式；
匿名代码块不使用任何修饰符，在静态代码块之后执行，每次实例化执行一次；用于初始化；
构造体 在匿名代码块执行执行

抽象类和抽象方法

abstruct 修饰的类或这方法
抽象类中可以有抽象方法和非抽象方法；
单继承
抽象方法，不能实现方法体
不能new，只能通过其他继承它的类来new
继承抽象类的方法，必须将其中的抽象方法都实现了；

接口

用interface修饰的类
所有抽象的特征，接口都会拥有
接口中的方法默认都是用public abstruct来修饰的；所以直接写方法返回值类型和方法名及方法参数就可以了；
可以使用implements来通过类实现这个接口，支持多继承

内部类

在一个类的内部定义一个类。
Out out = new Out();
out.Inner inner = out.new Inner();
普通内部类相当于外部类的一个普通属性，可以直接访问外部类的私有属性及方法；静态内部类是属于类的，仅仅可以拿到静态的属性和方法；
一个java文件中只能有一个public 类，但是可以其他有普通的类型；
匿名内部类，定义一个类的同时，实例化这个类；

异常

在这里插入图片描述

try {
}
catch (Exception e){
e.printStackTrace(); // 打印报错的堆栈信息
throw new Exception(); // 主动抛出异常 一般和 throws Exception，将异常往外抛出；这样编译可以通过；
}
finial{
// 不管是否捕获到异常都会执行的代码
}

catch可以有多个，但是需要从低到高，依次补货
idea快捷键: ctrl + alt + T;

注解

注解：不影响程序的运行。但是可以有一定的提示及限制作用
元注解：注解的注解；
@target 可以在哪些位置使用当前注解；
@Retention 在哪个生命周期该注解发挥作用；一般传递 “RUNTIME” 表示运行的时候都是有效的
@Document 是否生成到文档JavaDoc中
@Inherited 子类可以继承
定义
@元注解
public @interface 注解名称 {
 参数类型 参数名() default 参数默认值;
}
如果注解在定义的时候有没有默认值的参数，那么在使用注解的时候必须添加参数；

反射

实现动态语言的功能，但是损失了一部分性能
获取class对象
对象.getClass() 得到一个Class类对象；与实例化一个对象的方向相反；
Class.fromName("包路径.类名")同样可以获得一个类对象；
class类名.class
Class类对象
对于每一个类JRE(java运行时环境)中都保留唯一一个不变的Class类型的对象，一个Class对象包含了特定的结构（属性，方法等）
通过class类对象可以获取，类的所有public方法属性及private方法属性，及父类的public属性和方法；
在关闭了权限检测之后就可以直接操作私有属性或方法；
通过反射同样可以读取代码中的注解信息；
Class AClass = Class.fromName("包路径及类名");
obj obj = AClass.newInstance();
field name = AClass.getDeclaredField("属性名称");
name.setAccessible(true); // 可以提升代码效率，开启访问权限
name.set(obj, "xiaom");
通过反射来操作参数泛型和结果泛型；
类加载过程
Java 类运行过程

类的加载到内存
将堆中的Class对象指向特殊方法区中的这个Class类对象的静态static数据；此时在堆中就存在了Class类对象；
类的链接
为类中的属性初始化为该类型的默认值；
在通过类实例化对象的时候
类的初始化
通过clinit方法，会将所有的static代码执行一遍；该方法可以保证，类在多线程中是安全的；

会使类初始化的操作
主动引用，如果父类没有被初始化，先初始化父类
反射和主动引用类似
不会初始化的操作
使用类中的静态方法或属性，因为静态方法直接在特殊方法区中
子类调用父类的静态属性或方法，并不会使子类初始化，只会初始化父类；（为什么还会初始化父类呢？）
使用类中的常量属性，常量在链接阶段就存入静态池中，所以不会触发任何类的初始化；
数组在初始化的时候，其对应的类并不会被加载；
类加载的作用
将编译的字节码文件，加载到内存中，并将这些静态数据转换为方法区中的运行时数据结构，然后在堆内存中生成一个对应的java.lang.Class对象，作为方法区中类数据访问的入口；
双亲委派机制
会先加载java中自带的类，再加载用户自定义的类；更加安全；
类缓存
标准javaSE类加载器一旦将类加载到内存中，会维持一段时间（缓存），但是也会被jvm回收机制gc回收；

岳大博

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础

Java基础Idea的使用注释基本数据类型（关键字）整形浮点类型字符类型布尔类型引用数据类型类型转换变量常量运算符包机制代码执行类重载可边长参数数组Idea的使用创建一个空项目为空项目创建一个模块为项目配置运行环境。project structure > SDK: 1.8.0; language level: 8注释单行注释 //多行注释以 /开头文档注释以/* 开头基本数据类型（关键字）整形byte 一个字节8bits；所以最多表示 2^7个大小，最高一个位置用来
复制链接

扫一扫