Java基础教程秘籍-4章_面向对象-上

已于 2024-08-16 12:44:25 修改
阅读量335 收藏 4
点赞数 8
分类专栏： Java基础&高级教程秘籍 文章标签： java python 开发语言
于 2024-08-16 11:37:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41171614/article/details/141254729
版权

📌Java基础教程秘籍-4章_面向对象-上

一、类与对象

【面向对象是java核心！！要求都比较高，要关注每个细节，对自己的要求是100%，全部都要掌握！； 面向对象的学习一定要落实到代码上；】

1.面向对象学习的三条主线

【非常重要，以下内容按照此展开！！】

  • 1.Java类及类的成员：属性、方法、构造器【非常重要！！】；代码块、内部类【开发中用得少！！】

  • 2.面向对象的大特征：封装性、继承性、多态性、(抽象性) 【从代码中理解即可！！】

  • 3.其它关键字：this、super、static、final、abstract、interface、package、import等

“大处着眼，小处着手”
【抓重点学习！！】

2.面向对象与面向过程（理解）

  1. 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
  2. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做【名词主体，重点是找对象！！】。
    【结构更加清晰，功能更加容易拓展！！！】
    举例对比：人把大象装进冰箱。
  • ① 把冰箱门打开
  • ② 抬起大象，塞进冰箱
  • ② 把冰箱门关闭
* 人{
* 	打开(冰箱){
* 		冰箱.开开();
* 		}
* 
* 	抬起(大象){
* 		大象.进入(冰箱);
* 		}
* 
* 	关闭(冰箱){
* 		冰箱.闭合();
* 		}
* 
* }
* 
* 
* 冰箱{
* 	开开(){}
* 	闭合(){}
* }
* 
* 大象{
* 	进入(冰箱){}
* }

3.完成一个项目（或功能）的思路：

在这里插入图片描述

【名词对应类，动词对应类中的方法！！】

4.面向对象中两个重要的概念：

  • 类：对一类事物的描述，是抽象的、概念上的定义
  • 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

>面向对象程序设计的重点是类的设计
>设计类，就是设计类的成员。

二者的关系：
对象，是由类new出来的，派生出来的。

5.面向对象思想落地实现的规则一

  • 1.创建类，设计类的成员【重点：花的时间最多！！！java已经写好了很多类，直接调用即可】
  • 2.创建类的对象
  • 3.通过“对象.属性”或“对象.方法”调用对象的结构

补充：几个概念的使用说明

  • 属性 = 成员变量 = field = 域、字段
  • 方法 = 成员方法 = 函数 = method
  • 创建类的对象 = 类的实例化 = 实例化类

6.对象的创建与对象的内存解析

典型代码：

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。

说明：
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

内存解析：
在这里插入图片描述

通常所说的栈指虚拟机栈，存放局部变量；
堆中存放对象实例；
方法区中存储类信息、常量【字符串常量池】、静态变量
以下对象定义在main方法中，全部都是局部变量，存放在栈中
在这里插入图片描述

这部分一定要理解透！
在这里插入图片描述

以上数组的元素是一个类，属于引用类型，给数组元素赋值就是实例化类！！这部分要理解！！跟String相同

7.匿名对象:我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。
举例：

	new Phone().sendEmail();
	new Phone().playGame();
	
	new Phone().price = 1999;
	new Phone().showPrice();//0.0

应用场景：

PhoneMall mall = new PhoneMall();

//匿名对象的使用   匿名对象可以做参数！！可以简化代码
mall.show(new Phone());

其中，

class PhoneMall{
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
}

8.理解"万事万物皆对象"

  1. 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
  • >Scanner,String等
  • >文件：File
  • >网络资源：URL
  1. 涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。【？？？？】

【作业：】

  1. 讲完面向对象之后，画出思维导图；

1）Jvm内存结构

  • 编译完源程序以后，生成一个或多个字节码文件！！！。
  • 我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
    在这里插入图片描述

《JVM规范》

  • 虚拟机栈，即为平时提到的栈结构。将局部变量存储在栈结构中

  • 堆，我们将new出来的结构（比如：数组、对象）加载在堆空间中。补充：对象的属性（非static的）加载在堆空间中。

  • 方法区：类的加载信息、常量池、静态域（静态变量）

  • 内存结构：栈（局部变量）、堆(new出来的结构:对象(非static成员变量)、数组)

变量：成员变量 vs 局部变量（方法内、方法形参、构造器内、构造器形参、代码块内）

二、类的结构之一：属性

类的设计中，两个重要结构之一：属性

对比：属性（成员变量） vs 局部变量

1.相同点：

  • 1.1 定义变量的格式：数据类型 变量名 = 变量值
  • 1.2 先声明，后使用
  • 1.3 变量都其对应的作用域

2.不同点：

2.1 在类中声明的位置的不同

  • 属性：直接定义在类的一对{}内
  • 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2 关于权限修饰符的不同

  • 属性：可以在声明属性时，指明其权限，使用权限修饰符。
  • 常用的权限修饰符：private、public、缺省、protected —>封装性
  • 目前，大家声明属性时，都使用缺省就可以了。
  • 局部变量：不可以使用权限修饰符。

2.3 默认初始化值的情况：
属性：类的属性，根据其类型，都默认初始化值。未赋值之前可以直接调用。

  • 整型（byte、short、int、long：0）

  • 浮点型（float、double：0.0）

  • 字符型（char：0 （或’\u0000’））

  • 布尔型（boolean：false）

  • 引用数据类型（类、数组、接口：null）

  • 局部变量：没默认初始化值。
    意味着，我们在调用局部变量之前，一定要显式赋值。
    特别地：形参在调用时，我们赋值即可。

2.4 在内存中加载的位置：

  • 属性：加载到堆空间中 （非static）
  • 局部变量：加载到栈空间

补充：回顾变量的分类：
方式一：按照数据类型：
在这里插入图片描述

方式二：按照在类中声明的位置：
在这里插入图片描述

三、类的结构之一：方法

类的设计中，两个重要结构之二：方法
方法：描述类应该具的功能。

  • 比如：
Math类：sqrt()\random() \...
Scanner类：nextXxx() ...
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...

1.举例：

 * public void eat(){}
 * public void sleep(int hour){}
 * public String getName(){}
 * public String getNation(String nation){}

2. 方法的声明：

权限修饰符  返回值类型  方法名(形参列表){
				方法体
}
  • 注意：static、final、abstract 来修饰的方法，后面再讲。

3. 说明：

3.1 关于权限修饰符：默认方法的权限修饰符先都使用public

  • Java规定的4种权限修饰符：private、public【用的多】、缺省、protected -->到封装性再细说

3.2 返回值类型： 返回值 vs 没返回值

3.2.1 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用

  • return关键字来返回指定类型的变量或常量：“return 数据”。【方法中一定要有返回值！！】
  • 如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要
  • 使用return；但是，如果使用的话，只能“return;”表示结束此方法的意思。

3.2.2 我们定义方法该不该返回值？
① 题目要求
② 凭经验：具体问题具体分析

3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

3.4 形参列表： 方法可以声明0个，1个，或多个形参。

3.4.1 格式：数据类型1 形参1,数据类型2 形参2,…

3.4.2 我们定义方法时，该不该定义形参？
① 题目要求
② 凭经验：具体问题具体分析

3.5 方法体：方法功能的体现。

4. 方法的使用中，可以调用当前类的属性或方法！！！

特殊的：方法A中又调用了方法A:递归方法。
方法中，不可以定义方法。

【练习】

public void sleep(int hour){
		System.out.println("休息了"+hour+"个小时");
//		eat();
		sleep(10);  //栈溢出了，虽然有垃圾回收机制，但是依旧导致内存溢出
	}

1）关键字:return

return关键字：

  1. 使用范围：使用在方法体中
  2. 作用：① 结束方法 【没有返回值的情况】
    ② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据并结束方法。 【有返回值的方法】
  3. 注意点：return关键字后面不可以声明执行语句。

2）方法的重载

  1. 方法的重载的概念
    定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

总结：“两同一不同”:同一个类、相同方法名

参数列表不同：参数个数不同，参数类型不同 【参数比较时要一一对应！第一个和第一个比，第二个和第二个比】

  1. 构成重载的举例：
    举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
    举例二：
//如下的4个方法构成了重载
	public void getSum(int i,int j){
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2){
		System.out.println("2");
	}
	
	public void getSum(String s ,int i){
		System.out.println("3");
	}
	
	public void getSum(int i,String s){
		System.out.println("4");
	}

不构成重载的举例：

//如下的3个方法不能与上述4个方法构成重载
//	public int getSum(int i,int j){
//		return 0;
//	}
	
//	public void getSum(int m,int n){
//		
//	}
	
//	private void getSum(int i,int j){
//		
//	}
  1. 如何判断是否构成方法的重载？
    严格按照定义判断：两同一不同。
    跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！
  2. 如何确定类中某一个方法的调用：
    方法名 —+ 参数列表

面试题：方法的重载与重写的区别？
【两者之间没有关系！！只是看着像而已】

throws\throw
String\StringBuffer\StringBuilder
Collection\Collections
final\finally\finalize
...
  1. 抽象类、接口
  2. sleep() / wait()

3）可变个数形参的方法

  1. 使用说明：
    1.jdk 5.0新增的内容
  2. 具体使用：
  • 2.1 可变个数形参的格式：数据类型 … 变量名
  • 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
  • 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
  • 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
  • 2.5 可变个数形参在方法的形参中，必须声明在末尾
  • 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

【新特性和旧特性只能选择其一，本质上就是一个数组！】

 //JDK 5.0以前： 采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0： 采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);
  1. 举例说明：
 	public void show(int i){
		
	}
	
	public void show(String s){
		System.out.println("show(String)");
	}
	
	public void show(String ... strs){  //本质上还是数组
		System.out.println("show(String ... strs)");
		
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
	}
	//不能与上一个方法同时存在
//	public void show(String[] strs){
//		
//	}

调用时：

	test.show("hello");
	test.show("hello","world");
	test.show();
	
	test.show(new String[]{"AA","BB","CC"});  //可以省略new string，也可以加上

4）java的值传递机制

【重点+难点！！】

  1. 针对于方法内变量的赋值举例：
System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;

System.out.println("m = " + m + ", n = " + n);

n = 20;

System.out.println("m = " + m + ", n = " + n);

System.out.println("***********引用数据类型：****************");

Order o1 = new Order();
o1.orderId = 1001;

Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。

System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

o2.orderId = 1002;

System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

规则：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

  1. 针对于方法的参数概念
    形参：方法定义时，声明的小括号内的参数
    实参：方法调用时，实际传递给形参的数据
  2. java中参数传递机制：值传递
    规则：【很重要！！】
  • 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
  • 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

推广：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

4.典型例题与内存解析：
【例题1】
在这里插入图片描述

【例题2】

//此处的m和n是方法中的局部变量，与前面的m和n有本质区别
test.swap(data);
//注意此处进行了一次赋值操作，引用类型变量
public void swap(Data data2){
	int temp = data2.m;
	data2.m = data2.n;
	data2.n = temp;
}

在这里插入图片描述

// 数组排序
	public void sort(int[] arr) {
		// 冒泡排序
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					//int temp = arr[j];
					//arr[j] = arr[j + 1];
					//arr[j + 1] = temp;
					//错误的：
					//arr[j],arr[j + 1]相当于两个局部变量，在swap执行完后释放了！！！
					//swap(arr[j],arr[j + 1]);
					//正确的：
					swap(arr,j,j + 1);
				}
			}
		}
	}

//错误的：交换数组中指定两个位置元素的值
//public void swap(int i,int j){
//	int temp = i;
//	i = j;
//	j = temp;
//}
//正确的：交换数组中指定两个位置元素的值
public void swap(int[] arr,int i,int j){
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

【例题3】
在这里插入图片描述

public class TransferTest3 {
    public static void main(String args[]) {
        TransferTest3 test = new TransferTest3();
        test.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);  //20
    }
    //此处进行赋值操作
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);  //15
    }
}

class Value {
    int i = 15;
}

例题

int[] arr = new int[]{1,2,3};
System.out.println(arr);  //地址值

char[] arr1 = new char[]{'a','b','c'};
System.out.println(arr1);   //abc

例题
【String这个类比较特殊】

public static void main(String[] args) {
		String s1 = "hello";
		ValueTransferTest test = new ValueTransferTest();
		test.change(s1);
		System.out.println(s1);   //hello
	}
	public void change(String s){
		s = "hi~~";  //s单独再去指向一个地址，之前的s1地址不改变
	}
}

5）递归方法

【了解即可！！】
【快排中使用就是递归！】

  1. 定义：
    递归方法：一个方法体内调用它自身。
  2. 如何理解递归方法？
    > 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
    > 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
  3. 举例：
// 例1：计算1-n之间所自然数的和
	public int getSum(int n) {// 3

		if (n == 1) {
			return 1;
		} else {
			return n + getSum(n - 1);
		}

	}

	// 例2：计算1-n之间所自然数的乘积:n!
	public int getSum1(int n) {

		if (n == 1) {
			return 1;
		} else {
			return n * getSum1(n - 1);
		}

	}
	
	//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	//其中n是大于0的整数，求f(10)的值。
	public int f(int n){
		if(n == 0){
			return 1;
		}else if(n == 1){
			return 4;
		}else{
//			return f(n + 2) - 2 * f(n + 1);
			return 2*f(n - 1) + f(n - 2);
		}
	}

例4：斐波那契数列

		1	n=1
F(n)=	1	n=2
		F(n-1)+F(n-2)  n>2

例5：汉诺塔问题
(1) 以C盘为中介，从A杆将1至n-1号盘移至B杆；
(2) 将A杆中剩下的第n号盘移至C杆；
(3) 以A杆为中介；从B杆将1至n-1号盘移至C杆

例6：快排
【自己实现？？】

四、面向对象的特征一：封装性

1.为什么要引入封装性？

我们程序设计追求“高内聚，低耦合”。

  • 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合 ：仅对外暴露少量的方法用于使用。 【权限修饰符！！】

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.问题引入：

当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。
这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。
但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。

这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
–>此时，针对于属性就体现了封装性。

【给属性添加约束条件+外面不能调用属性】

3.封装性思想具体的代码体现：【这个只是体现，而不是封装性！】

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

//对属性的设置
//给属性增加一个接口，外面不能调用legs属性
public void setLegs(int l) {
    if (l >= 0 && l % 2 == 0) {
        legs = l;
    } else {
        legs = 0;
    //抛出一个异常（暂时没有讲）
    }
}

//对属性的获取
public int getLegs() {
    return legs;
}


private double radius;
public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4.Java规定的四种权限修饰符

4.1 权限从小到大顺序为：private < 缺省 < protected < public

4.2 具体的修饰范围：

【这个表格需要记住！！】
在这里插入图片描述

上面这种情况是一个包；
 default类只可以被同一个包内部的类访问。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：
· 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
· 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

4.3 权限修饰符可用来修饰的结构说明：

4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类 【？？】
修饰类的话，只能使用：缺省、public

五、类的结构之三：构造器

【任何一个类都有一个构造器；构造器和方法没有关系，两者是不一致的；构造器必须和类同名】

1.构造器（或构造方法）：Constructor

构造器的作用：

  • 1.创建对象 【Construct】
  • 2.初始化对象的信息

2.使用说明：

  • 1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器！！！
  • 2.定义构造器的格式： 权限修饰符 类名(形参列表){}
  • 3.一个类中定义的多个构造器，彼此构成重载
  • 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
  • 5.一个类中，至少会有一个构造器。

3.举例：

//构造器:与类同名，显示的写出来构造器
	public Person(){
		System.out.println("Person().....");
	}
	//创建构造器的同时给属性赋值，通常初始化属性
	public Person(String n){
		name = n;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}

1）属性赋值顺序

  • 总结：属性赋值的先后顺序

  • ① 默认初始化

  • ② 显式初始化

  • ③ 构造器中初始化

  • ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值 【可以执行很多次！！】

以上操作的先后顺序：① - ② - ③ - ④

		User u1 = new User(2);
		
		u1.setAge(3);
		u1.setAge(5);
		
		System.out.println(u1.age);
	}
}

class User{
//默认初始化
	String name;
//显示初始化
	int age = 1;
	
	public User(){
	}
	//构造器中初始化
	public User(int a){
		age = a;
	}
	//通过"对象.方法" 或 "对象.属性"的方式赋值
	public void setAge(int a){
		age = a;
	}
	
}

2）JavaBean的概念

所谓JavaBean，是指符合如下标准的Java类：
>类是公共的
>一个无参的公共的构造器
>属性【私有化的！】，且对应的get、set方法
UML类图
在这里插入图片描述

六、关键字：this

1.可以调用的结构：属性、方法；构造器

2.this调用属性、方法：

this理解为：当前对象 或 当前正在创建的对象

2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，

  • 通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
  • 的使用"this.变量"的方式，表明此变量是属性，而非形参。

2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this调用构造器：

【不用谢冗余的代码，减少重复代码！！】
① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器 【？？】
② 构造器中不能通过"this(形参列表)“方式调用自己
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”
④ 规定："this(形参列表)“必须声明在当前构造器的首行
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

七、关键字：package/import

1. package的使用

1.1 使用说明：

  • 1.为了更好的实现项目中类的管理，提供包的概念
  • 2.使用package声明类或接口所属的包，声明在源文件的首行
  • 3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
  • 4.每"."一次，就代表一层文件目录。

1.2 举例：

举例一：
某航运软件系统包括：一组域对象、GUI和reports子系统
在这里插入图片描述

举例二：MVC设计模式
在这里插入图片描述

1.3 JDK中的主要包介绍：

在这里插入图片描述

2. import的使用：

import:导入

    1. 在源文件中显式的使用import结构导入指定包下的类、接口
    1. 声明在包的声明和类的声明之间
    1. 如果需要导入多个结构，则并列写出即可
    1. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所结构
    1. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
    1. 如果使用的类或接口是本包下定义的，则可以省略import结构
    1. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
    1. 使用"xxx.*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
    1. import static:导入指定类或接口中的静态结构:属性或方法。

整理不易🚀🚀，关注和收藏后拿走📌📌欢迎留言🧐👋📣✨
快来关注我的公众号🔎AdaCoding 和 GitHub🔎 AdaCoding123
在这里插入图片描述

AdaCoding
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础教程秘籍-1章_Java语言概述
weixin_41171614的博客
05-01 776
Java基础教程秘籍-1章_Java语言概述
java基础教程----精华版
09-22
Java是一种广泛使用的面向对象的编程语言，以其平台独立性、安全性、健壮性和高性能而闻名。这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java...
Java基础教程 - 7 面向对象-4
山石岐渡的博客
05-20 1461
多态就是多种状态，同一个类型的父类型对象，因为指向的是不同的子对象，而表现出的不同的状态。所以多态是建立在继承的基础之上的。System.out.println("我会啾啾叫");System.out.println("我会咕咕叫");// 创建一个麻雀对象// 创建一个鸽子对象上面麻雀类和鸽子类都继承自鸟类，然后创建了一个麻雀对象和鸽子对象，都赋给了鸟类，通过两个对象分别调用 tweet() 方法。执行结果：我会啾啾叫我会咕咕叫。
7-4 jmu-Java-03面向对象基础-04-形状-继承 (15 分)
世界在我口袋的博客
03-11 2436
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() 2. Rectangle与Circle类均继承自Shape类。 Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
黑马Java零基础视频教程精华部分_12_面向对象进阶(4)_内部类
buyaotutou的博客
08-04 777
它是类的五大成员(属性、方法、构造方法、代码块、内部类)之一。在一个类的里面，再定义一个类。举例:在A类的内部定义B类，B类就被称为内部类，如下图所示，Inner类就是内部类，Outer类就是外部类，他俩之外的其他类，统称为外部其他类。
黑马Java零基础视频教程精华部分_9_面向对象进阶(1)_static、继承
buyaotutou的博客
07-29 2025
在一般的一个类中的普通成员函数，其实自带一个参数就是调用者的地址值，如下图所示,s1.show1()在执行时，就自动将s1的地址传入了函数show1中，然后show1如果要输出属性，就可以知道输出的是s1的属性，而再调用show2时候，默认还是show1参数的那个地址来调用show2（下图可以省略show2前面的this,一般这个this是隐含的)。而静态方法的参数中，没有自带那个this参数，我们也不能自己设置，所以静态方法中使用this是不可以的，计算机不知道this指的是谁。不属于对象，属于类。
Java-based-tutorial.rar_java 基础教程
09-20
**Java基础教程** Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。它以其“一次编写，到处运行”的特性而闻名，因为Java程序可以在任何支持Java虚拟机（JVM）...
Java-Java面向对象编程教程
11-13
除了这些基础概念，Java面向对象编程还包括其他重要主题，如构造器、抽象类和接口、异常处理、包（Package）、访问修饰符和内部类等。构造器用于初始化新创建的对象；抽象类不能被实例化，但可以被其他类继承；接口...
Java-Java面向对象继承的实现教程
11-09
本教程将深入探讨Java中面向对象继承的实现。 首先，理解继承的基本概念。继承允许子类继承父类的所有非私有（public和protected）成员，包括字段（变量）和方法。这减少了代码重复，提高了代码的复用性。子类可以...
完整版 Java编程基础入门教程 Java语言程序设计 第3章_面向对象程序设计基础（共16页）.ppt
12-18
Java编程基础入门教程的第三章主要讲解了面向对象程序设计的基础知识。面向对象编程（OOP）是一种基于对象和类的编程范式，它强调通过模拟现实世界中的实体及其交互来构建软件系统。以下是该章节的主要知识点： 1. ...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 520
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 767
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 516
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 228
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 807
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 907
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 655
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 220
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 894
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值