（三）JavaSE基础知识汇总

HB0o0

已于 2023-03-28 20:21:10 修改

阅读量138

点赞数 3

分类专栏： Java基础文章标签： java jvm 面试

于 2023-03-20 16:45:30 首次发布

本文链接：https://blog.csdn.net/SwaggerHB/article/details/129670923

版权

Java基础专栏收录该内容

16 篇文章 3 订阅

订阅专栏

Java基础知识

Java标识符命名规则

命名规则

1.标识符可以由字母、数字、下划线（_）和美元符($）组成，不能以数字开头；

2.标识符严格区分大小写；

3.标识符不能是Java关键字和保留字；

4.标识符的命名最好能反映出其作用；

Java关键字

在这里插入图片描述

Java八大基本类型

与C语言不同，Java除C语言中存在的char、short、int、long、float、double这6种最基本的数据类型外，还存在另外两个Java特色的基本数据类型：byte 和 boolean；

byte类型是1字节补码。

boolean类型就是布尔型，即是逻辑型；其取值只有两种： true 和 false。

Java的long类型需要注意，与C的long不同！Java的long是8字节补码！使得整型量的表达范围在-9223372036854774808~9223372036854774807（-2的63次方到2的63次方-1）。

在这里插入图片描述

另外一个问题需要大家特别注意：

在Java中，没有unsigned类型修饰符，也就是说，Java中的类型都是补码，没有无符号数这个概念！

变量定义及生命域

在学习C语言时，为了程序的可移植性，强调尽量不要使用C99标准。但是，Java的变量定义有所不同：可以在任何需要某变量时，再定义它，无需早早定义。可以在for ()中定义一个变量，而这个变量的生命域只在这个循环中，循环结束，其空间就被释放。

另外，Java函数的变量生命域与C语言函数的变量生命域相同。

变量的命名规范

所有变量、方法、类名： $\textcolor{red}{见名知意}$

类成员变量：首字母小写以及驼峰原则；（驼峰原则：handsomeBoy）

局部变量：首字母小写及驼峰原则；

常量：大写字母及下划线，例：MAX_ROW;

类名：首字母大写及驼峰原则；

方法名：首字母小写及驼峰原则；

Java运算符

算术运算符： +，-，*，/（加减乘除）；%（取余）；++，-- （自增自减）

赋值运算符：= （赋值）；

关系运算符：<，>，>=，<=，==，!=（不等于），instanceof；

instanceof，（它的左边是对象，右边是类，返回类型是Boolean类型。用来测试左边的对象是否是右边类或者该类的子类创建的实例对象，是则返回true，否则返回false）

逻辑运算符：&&，||，！

位运算符：&，|，^，~，>>，<<，>>>

条件运算符：？，：

面向过程和面向对象

C语言是一个面向过程程序设计语言；Java是一个面向对象程序设计语言。

在面对编程问题时，C语言实现的思想角度是：解决这个问题需要哪些“过程”，及这些过程的进一步细分，最终形成一个一个功能函数，通过组合、协调这些函数，最终实现这个过程。

而Java在实现相同问题时，首先思考的是，问题本身由哪些“部件”（对象）组成；这些部件本身有哪些属性（成员）和操作（方法）？部件和部件之间有什么内在联系，以及部件是如何联系起来的，最终也能实现应用目的。

但是，这样的回答，对于初学Java是很难理解的。但，这确实就是面向对象程序设计思想！

面向对象编程思想

物以类聚，分类的思维模式，思考问题，首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，对某个分类下的细节进行面向过程的思考。（面向对象适合处理复杂的问题，适合处理需要多人协作的问题）

面向对象编程（Object-Oriented Programming，OOP）

本质：

$\textcolor{red}{以类的方式组织代码，以对象的组织（封装）数据}$

目标— —代码复用

换一个角度讲述面向对象的编程思想，可能会好些吧？面向对象编程思想的终极目标是：代码复用！代码复用，简言之就是能够重复使用已经编好的代码。

其实代码复用的思想在面向过程的C语言中也是存在的。最经典的案例就是库函数和“用函数编程”的设计思想。

核心— —完整的工具

“完整的工具”应该包含两个要素：数据和操作！

将工具的数据和对数据的操作捆绑、封装在一起，这就是面向对象程序设计思想的出发点！

“完整的工具”— —类

类，就是类型的意思。也就是说，定义一个类，就等于产生了一种新的数据类型。

三大特性：

封装、继承、多态

从认识角度考虑：先有对象后有类。对象，是具体的事物。类是抽象的，对对象的抽象。

从代码角度考虑：先有类后有对象。类是对象的模板。

工具需要”保护“— —权限修饰符

Java开发者（前辈）们，在语法层面给出了保护的具体做法——权限修饰符：public，protected，private；

public 修饰的成员和方法，可以在类外任意访问（读/写）；

private 修饰的成员和方法，只能在类的内部进行访问。

通常情况下，类的成员都需要private保护，而类的方法都是public的，以便“公开”，方便调用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IfhsWQHq-1679301845579)(C:\Users\86137\Desktop\QQ截图20230320124810.png)]

public和 private相对简单，是两个极端:从”保护“功能讲，public最弱，private最强；

protected 修饰的成员和方法，无论是否在同一个包下，子类都可以继承；且，同一包下的类，可以通过其对象引用。

无修饰的成员和方法，在同一包下的子类可以继承，不在同一包下的子类不能继承；且，不在同一包下的其非派生类，不能引用。

构造方法的基本规则一包下的子类不

1、 构造方法必须与类同名；

2、 构造方法不能声明其返回值类型；（void都不可以）

3、 对于构造方法，用户不能按普通方法调用；

4、 构造方法只能在类实例化对象时（“被new”时）被调用；

5、 构造方法的主要目的，就是初始化对象诸成员的值。

关于new

SimplePointpointOne = new SimplePoint();

这条语句完成三组操作：

1、申请SimplePoint类的一个实例空间；

2、 完成对该实例空间中诸成员赋初值（调用构造方法）；

3、将实例空间的首地址赋值给对象 pointOne。

这就是关键字new的内在操作过程。

工具的“大爱”与“担当”——方法的重载

核心目的：对于类似功能，仅仅是参数个数或者参数类型不一致的方法，允许方法名称不变。这就使得方法的使用者无需再记忆大量的函数。

方法重载的基本规则

1、 方法名称相同；

2、 参数个数或者参数类型不同；

3、 返回值类型的差异不是方法重载的决定因素；

4、 构造方法也可以重载，只要满足前2点规则。

构造方法的重载

public class Point {
	private int row;
	private int col;
			
	public Point() {
		System.out.println("This is none argument constructor!");
		setRow(0);
		setCol(0);
	}
			
	public Point(int x, int y) {
		System.out.println("This is 2 arguments constructor!");
		setRow(x);
		setCol(y);
	}
			
	public Point(int x) {
		System.out.println("This is singel argument constructor!");
		setRow(x);
		setCol(0);
	}
			
	public Point(MecPoint point) {
		System.out.println("This is object argument constructor!");
		setRow(point.row);
		setCol(point.col);
	}
			
	public void setPoint(int x, int y) {
		setRow(x);
		setCol(y);
	}
				
	public void setPoint(int x) {
		setPoint(x, 0);
	}
				
	public void setPoint(MecPoint source) {
		setPoint(source.row, source.col);
	}
			
	public void setRow(int x) {
		if (x <= 0 || x > 25) {
			x = 1;
		}
		row = x;
	}
				
	public int getRow() {
		return row;
	}
				
	public void setCol(int y) {
		if (y <= 0 || y > 80) {
			y = 1;
		}
		col = y;
	}
				
	public int getCol() {
		return col;
	}
			
	public void printPoint() { 
		System.out.println("(" + row + ", " + col + ")");
	}
			
	public void moveTo(int newRow, int newCol) {
		row = newRow;
		col = newCol;
	}
}

关于 this

Java中 this 是什么

相信大家都通过Eclipse或Idea自动补全功能自动生成了很多代码，这些代码中，频繁出现了一个关键字this，他是什么？起什么作用？怎么用？

先看一个setter代码：

	public void setRow(int row) {
		if(row <= 0 || row> 25) {
			row = 1;
		}
		this.row = row;
	}

第5行这里出现了一个this，这个this能不要吗？可以是可以，但第5行的意思会发生改变。

将第5行row前面的this关键字去掉，也就是说将第5行变成了row = row，那么这个row变量实质上实质上是方法setRow()的形参变量row，而并非真正要操作的对象：成员 row。

为了明确告知Java编译器，第5行等号左侧的row应该是成员row，所以需要this来加以区分。

上述说明了this的第一种作用：区分局部变量和成员变量

this的第二种作用：指代对象本身。

关键需要明白，方法（并非所有）的调用必须需要通过对象才能进行。

即对象.方法()是方法调用的基本形式！ 那么所调用的方法中，如果存在this，那么这个this就代表：调用这个方法时的“引领”者— —那个对象。

this() 表示什么

我们可以看到，this 的后面有()，说明JVM将其当作“方法”看待；并且这个方法固定表示“ 构造方法 ”。例如：

public class Point {
	private int row；
	private int col;
	
	public Point(int row, int col) {
		setRow(row);
		setCol(col);
	}
	
	public Point(int row, int col) {
		this(0,0);
	}
}

注意：用 this () 调用构造方法时，要注意：

1、参数个数决定其调用的具体构造方法，即，无参还是带参构造；

2、this() 只能在构造方法中出现；

3、构造方法中若出现 this() ，则必须是第一条语句；

4、this() 的使用应避免递归问题，当然，Java编译器拒绝递归构造；

关于 final 关键字

final是一个关键字，它可以被用来修饰变量，类以及成员方法。

final修饰变量

1、fianl修饰成员变量（指在类内-方法外定义的变量）

Java中final关键字相当于C语言中的 const关键字。被final修饰的成员变量，就是“只读变量”，或者“常变量”–一般使用大写字母表示。final修饰的成员变量，一定要初始化一次，且必须是在这个成员变量所在的类对象创建之前被初始化。

public final int MAX_ROW = 1;
public final int MAX_COL = 2;

2、final修饰局部变量（指在方法中定义的变量）

final修饰局部变量，在定义时该变量可以不被直接初始化，但是在使用该变量之前，该变量必须完成初始化。

	public Point() {
		final int row = 1;
	}

3、final修饰类

final修饰一个类，则该类会成为最终类，即该类不能被继承，但是该类可以有父类。

4、final修饰成员方法

当final关键字修饰了成员方法，则该方法不能被重写，但是可以被继承。

关于 static

这是一个有理解难度，同时也非常重要的 Java 概念！

前言

“变量的本质是内存中的一段连续存储空间”，这个概念对于Java成员变量依然适用。“内存空间的分配与回收”历来是理解和掌握变量生命域的理论基础。static 就涉及空间分配与回收的问题，且是理解 static 的关键。

静态存储分配模式

其实Java中的 static 继承了C语言中 static 关键字的核心”基因“，都属于”静态存储方式分配“。与C语言static一样，用 static 修饰的成员，其空间的申请操作远早于非 static 修饰的成员。

public class Point {
	private int row;
	private int col;
	
	public static int pointCount;
	
	public Point() {
	
	}
    
    public static int getPointCount() {
    	return pointCount;
    }
    
    public static void increasePointCount() {
    	++pointCount;
    }
    
}

上述引入 static 的 int 成员 pointCount；对于 pointCount 的操作，引入了两个 static 的方法。它们与非 static 的成员和方法又有什么区别呢？

为了讨论的方便，称有 static 修饰的成员和方法为”静态成员“和”静态方法“。

在 JVM 导入一个类（这个过程的专业术语叫”类加载过程“，而非对类实例化过程）时，就完成了对静态成员空间的申请。即：

JVM 对类加载时，就申请了就申请了静态成员的空间。

也就是说，在一个类还没有任何实例化的对象前，静态成员就已经存在了。

那么在没有任何类的对象前，能不能引用这个已经存在的静态成员呢？

public class Tset {
	public static void main(String [] args) {
		++Point.pointCount;
		System.out.println(Point.pointCount);
		
		Point.increasePoint();
		System.out.println(Point.getPointCount());
	}
}

注意第8行和第9行代码。在 pointCount 前,并没有出现pointOne 对象或者 Point 类的任何对象（代码中根本没有 new 过程)这里出现的是类名称！

类名称.静态成员 ，这就是静态成员在类外的引用方法！

方法必须通过对象来调用:对象.方法()是方法调用的基本形式。

但是,静态方法可以不通过任何对象来调用，可以用静态方法的引用方法调用静态方法，也就是用类名称调用静态方法。即上面代码的第11行和第12行。

类名称.静态方法()

从对静态成员和静态方法的调用语法角度看，可以得到一个有意思的结论：

静态成员是从属于大家（类）的共同财产；但是，静态成员不是“仅仅从属于一个人（对象）”的私有财产！

静态方法不能引用非静态成员和非静态方法

类的静态方法，可以在“没有实例化该类的任何对象”的前提下调用！但是，对于类的非静态成员，必须通过new关键字才获得其内存空间，也必须通过对象才能引用这个非静态成员。

静态方法中不允许出现 this

HB0o0

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
（三）JavaSE基础知识汇总

在学习C语言时，为了程序的可移植性，强调尽量不要使用C99标准。但是，Java的变量定义有所不同：可以在任何需要某变量时，再定义它，无需早早定义。可以在for ()中定义一个变量，而这个变量的生命域只在这个循环中，循环结束，其空间就被释放。另外，Java函数的变量生命域与C语言函数的变量生命域相同。Java中final关键字相当于C语言中的 const关键字。被final修饰的成员变量，就是“只读变量”，或者“常变量”–一般使用大写字母表示。
复制链接

扫一扫