Java——块，debug，package，import，GC，重写，final

最新推荐文章于 2022-02-20 15:34:04 发布

置顶肥瘦加糖

最新推荐文章于 2022-02-20 15:34:04 发布

阅读量312

点赞数

文章标签： java

本文链接：https://blog.csdn.net/globalzhang/article/details/105111130

版权

Java——对象(block & extends)

开闭原则: 对修改关闭,对扩展开放

块

语句块block 块 {}，自成作用域

局部代码块（普通语句块）：定义在方法中,跟随方法使用，声明一些临时变量；

构造代码块：定义在类中方法外，跟随new对象一起使用，构造块在构造器要执行的代码之前执行，如果有多个，从上到下一次执行；（为静态或非静态成员属性赋值）

静态块：类中方法外，只在类的第一次加载完后执行一次，如果有多个，从上到下一次执行（整个类进行某些初始化操作）；

block 块 {}

自成作用域
执行时机
{}->定义在方法中,局部代码块|普通语句块跟随方法使用
{}->定义在类中方法外,构造块跟随new对象一起使用
static{}->类中方法外,静态块类第一次加载
synchronized{} 同步块

注意:

构造块在构造器要执行的代码之前执行 ,如果有多个,从上到下一次执行
static块只在类第一次加载完车之后执行一次,如果存在多个,从上到下一次执行
执行顺序: static -> 主方法 ->构造块->构造器

public class BlockDemo01 {
	//成员变量  在对象内存空间 中
	static String name = "zhangsans";		//跟随对象使用
	
	//构造器
	public BlockDemo01() {
		System.out.println(name+"的构造器");
	}
	
	//构造块
	{
		System.out.println(name+"的构造块1");
	}
	{
		System.out.println(name+"的构造块2");
	}
	{
		System.out.println(name+"的构造块3");
	}
	
	//静态块
	static {
		System.out.println(name+"的静态块1");
	}
	static {
		System.out.println(name+"的静态块2");
	}
	
	public static void main(String[] args) {
		//局部变量
		int a=1;
		//普通语句块
		{
			System.out.println(a);
		}
		
		new BlockDemo01();
	}
}

执行顺序: static -> 主方法 ->构造块->构造器

debug

debug 调试

1.打断点
2.debug运行 f6执行到下一行

public class BlockTest02 {
	public static int a = 0;
	{
		a = 10;
		System.out.println("3、非静态代码块执行a=" + a); //10
	}	
	static {
		a = 6;
		System.out.println("1、静态代码块执行a=" + a); //6
	}
	public BlockTest02() { 
		this(a); //调用本类中其他构造器 有一个int类型参数构造器  a=6
		System.out.println("6、"+a);  //10
		System.out.println("7、无参构造方法执行a=" + a); //10
	}
	public BlockTest02(int n) {
		System.out.println("4、"+n); //6
		System.out.println("5、"+a); //10
	}	
	public static void main(String[] args) {
		System.out.println("2、main"); // main
		BlockTest02 tsc = new BlockTest02();	
	}
}

package & import

package是为了防止命名冲突造成的不便，java引入包机制，提供类的多重类命名空间

package类似一个文件夹，文件夹内有各种文件，package与package附属用英文句号 ” . “连接；

例如
java.lang.String 就是java文件夹中的 lang文件夹中的 String 文件。

java.io.InputStream 则是java文件中io文件夹中的InputStream文件

不同package内允许存在相同class类名；

	格式
	package语句作为java源文件的第一条语句，知名
	该文件中定义的类所在的包。
	package pkg1[.pkg2[.pkg3...]];
	或
	package com.java01.test; 	
	(该文件中所有的类位于.\com\java01  目录下)

注意：

不要定义与jdk相同的包，相同的类
加包不要使用默认包
com.oop 和 com.oop.test 这两个包没有包含关系，是两个完全独立的包（特例）
import
如果一个类存在报名，则在其他包下使用该类時，必须使用全额限定名（全名或完整类名，com.java.MyClass）。编译器才能找到该类；也可以使用import在文件的开头引入要使用的类。
```
 import java.util.Scanner;
 import java.io.*;	//模糊匹配当前io包下所有类
```

权限定名

导入集合：
java.util.ArrayList list = new java.util.ArrayList()

在导入语言包（java.lang）下的类（String.System…），和同包下的类時，不需要使用import
静态导入：import不仅可以导入类，还可以增加导入静态方法的功能

//导入静态属性
import static java.lang.Math.PI；
import static java.lang.System.out;
//导入静态方法
import static java.lang.Math.sin;

JDK中常用包简介

1. java.lang——语言包：语言中常用的功能，
   如：Stirng，Math，System，Integer，Thread...
2. java.util——工具包：提供一些使用的工具类，
   如：容器（List，Set，Map...），日期类
3. java.io——输入输出包：提供操作读取文件的相关类，
   如：File，InputStream，OutputStream...
4. java.net——网络包：操作远程资源的类，
   如：InetSocketAddress，DatagramPacket，ServerSocket...
5. java.sql——数据库包：操作JDBC的类，
   Connection，Statement，ResultSet...

GC (garbage collection)

程序运行时，内存空间有限，则将不再使用的对象释放出来，解决内存溢出需要GC。

1. 垃圾回收机制只回收JVM堆内存里的对象空间
2. 对其他物理连接，比如数据库连接，输入流输出流，Socket连接不起作用
3. 现在的JVM有多种垃圾回收实现算法，表现各异
4. 垃圾回收发生具有不可预见性，程序无法精确控制垃圾回收机制执行
5. 可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象
6. 程序员可以通过System.gc() 或者 Runtime.getRuntime().gc()来通知系
   统进行垃圾回收，会有一些效果，但系统是否执行不确定
7. 垃圾回收机制回收任何对象之前，总会先调用finalize方法（如果覆盖
   该方法，让一个新的引用变量从新引用该对象，则会重新激活对象）
8. 永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

继承

继承：使用继承可以提高代码复用

	1. 父类/超类/基类 ：根据一些子类抽象，抽取共有抽象部分，
	定义在父类中
	
	2. 子类/派生类 ：子类继承父类，有权使用父类中的内容，可以
	定义子类中的新增内容，所以子类是父类的延续+扩展实现类
	的继承机制；
	
	3. 用extends作为关键字

子类继承父类的成员变量和方法，不继承父类的构造方法
子类只有一个父类，想要实现多继承，则需要接口来实现
如果类没有调用extends，则默认其父类是：java.lang.Object

优点

	简化类的定义，事项代码的重用
	方便扩展程序
	继承父类后，可使用父类成员，同时扩展定义子类独有内容
	java单继承，实现简单

缺点

	子类依赖父类，独立性差
	只有一个父类，不够灵活，后期维护不便

super
super是指向父类的引用

	super可以在子类构造器中调用父类某个构造器
	若构造方法没有调用父类的构造方法，则编译器自动加上一个
	默认的super（）方法调用。如果父类由没有默认的无参构造方
	法，编译器会报错，super（）语句必须是构造方法的第一个字句；
	
	super可以用来区分子类父类中的同名成员
	如果不存在同名问题，可以直接在子类中调用父类内容，super
	默认省略；
	如果存在同名，则i累调用同名成员，默认this调用当前子类同名
	成员，先要调用父类同名成员，必须定义为super.成员

this 和 super

重写 & final

重写和重载：都是方法的特性

	方法的重载 : OverLoad
	一个类中的多个方法
	 方法名相同
	参数列表不同(方法签名:方法名+参数列表,来区分方法)
	
	方法的重写: Override
	不同的类
	继承|实现
	方法签名相同

重写方法:

当子类对父类中继承的某一个方法的方法体不满意,需要进
行修改,可以在子类中定义重写 方法,重新 定义方法体的实现

检查重写方法的方式:

左侧向上三角形
在重写方法的上面添加一个注解,强制检查是否为重写方法 @Override

调用 :
当子类重写了父类的方法时,子类采用就近原则使用自己的重写方法,子类如果没有重写,调用父类的

注意:子类重写了父类方法,会对父类方法进行屏蔽

重写的要求:

方法签名
返回值类型:基本数据类型->相同引用数据类型:子类<=父类
权限修饰符:子类>=父类

以下修饰符修饰的方法不能重写:

private修饰的方法不能被重写(无法继承)
final修饰的方法不能被重写
static修饰的方法不能被重写

注意:如果子类中存在与父类静态方法同名的方法,那么子类的方法要求也是static的
toString() 配合方法的重写可以实现把对象以字符串的形式展示|返回(所有成员属性的值)

如果不重写,使用Object类中的toString,展示的为类的包名+类名@地址值
==和equals区别:
== 比较数据值,对象的地址值
equals 如果使用Object类中的equals方法,比较的也是对象的地址值

public boolean equals(Object obj) {
        	return (this == obj);
    	}
    	配合方法的重写,实现比较对象内容而非地址
 *  
 *  注意: 如果以后自定义的模版类(User..Person..),
 * 都应该提供equals()和toString()
 */
public class EqualsDemo01{
	public static void main(String[] args) {
		//只要看到new就是一个新的对象,就是新的地址
		User user1 = new User(01,"lisi",19);
		User user2 = new User(01,"lisi",19);
		System.out.println(user1);
		System.out.println("结果:"+user1.equals(user2));  //比较地址
		System.out.println(user1==user2);  //比较地址
		//如果以后想要比较字符串内容是否相等,使用equals方法 进行比较
		String str1=new String("abc");
		String str2=new String("abc");
		System.out.println(str1==str2);
		System.out.println(str1.equals(str1));
	}
}

final

被final修饰的被不能被继承
被final修饰的方法不能被重写
被final修饰的变量为常量

Object 类

java.lang.Object 包下的常用方法

1. public boolean equals(java.lang.Object)比较对象的地址
   值是否相等，如果子类重写，则比较对象的内容是否相等；
2. public native int hashCode() 获取哈希码
3. public java.lang.String toString() 把数据转变成字符串
4. public final native java.lang.Class getClass() 获取类结
   构信息
5. protected void finalize() throws java.lang.Throwable垃
   圾回收前执行的方法 
6. protected native Object clone() throws 
   java.lang.CloneNotSupportedException克隆
7. public final void wait() throws java.lang.InterruptedException
   多线程中等待功能
8. public final native void notify() 多线程中唤醒功能
9. public final native void notifyAll() 多线程中唤醒
   所有等待线程的功能

下一篇，封装