Java 入门 (八)

博主： zmx
发布时间：2021 年 04 月 24 日
521 次浏览
暂无评论
4269字数
分类： Java

# main方法

```java
public static void main(String[] args){

}
//public：公开的，表示最大的权限
//static：静态，可以通过类名直接调用，是由jvm调用的
//void  ：不需要返回值
//main  ：就是以main作为入口的
//String[]: 字符串类型的数组，之前是用作键盘录入的
//args ：默认的，些啥都行，就是个变量名
```

# 继承

## 继承中成员变量之间的关系

如果父类的变量名和子类的变量名一致，那么有如下的访问规则：

1. 如果子类的局部范围内找，如果找到了就使用。
2. 如果找不到，那就去子类的成员位置去找，如果找到了就使用。
3. 如果找不到，那就去父类的成员位置去找，如果找到了就使用。
4. 以此类推，如果找不到，那就报错(不考虑父类的父类)\

如果变量名不一样，直接访问就好了。

```java
package top.zunmx.main;

// ALC-Master
class Fu {
	int i = 10;
	int j = 11;
	int k = 12;
}

class Zi extends Fu {
	int i = 20;
	int j = 21;

public void test() {
		int i = 30;
		System.out.println("i=\t\t" + i);
		System.out.println("this.i=\t\t" + this.i);
		System.out.println("super.i=\t" + super.i);
		System.out.println("j=\t\t" + j);
		System.out.println("k=\t\t" + k);
	}
}

public class Demo1 {
	public static void main(String[] args) {
		new Zi().test();
	}
}
/*
i=			30
this.i=		20
super.i=	10
j=			21
k=			12
*/
```

## 继承中构造方法之间的关系

如果父类没有无参数构造方法怎么办？但是父类有带参的

> 解决方案：
>
> 1. 子类能够访问到父类的构造方法就可以了，用super访问带参的(直接)
> 2. 给父类创建一个无参构造方法
> 3. 让子类的其中一个构造方法通过super访问父类的带参构造方法，子类的其它构造方法访问这个已经访问过父类的构造方法(间接方式)

```java
package top.zunmx.c1;

// ALC-Master
class Fu {
//	public Fu() {
//		System.out.println("#父类 无参数构造");
//	}
	public Fu(String s) {
		System.out.println("#父类 有参数构造" + s);
	}
}

class Zi extends Fu {
	public Zi() {
		//super("123");
		System.out.println("子类 无参数构造");
	}

public Zi(String s) {
		
		System.out.println("子类 有参数构造" + s);
	}
}

public class Demo {
	public static void main(String[] args) {
		Zi z1 = new Zi();
		Zi z2 = new Zi("123");
		
	}
}

```

```java
package top.zunmx.c1;

// ALC-Master
class Fu {
//	public Fu() {
//		System.out.println("#父类 无参数构造");
//	}
	public Fu(String s) {
		System.out.println("#父类 有参数构造" + s);
	}
}

class Zi extends Fu {
	public Zi() {
		super("123");
		System.out.println("子类 无参数构造");
	}

public Zi(String s) {
		this();
		System.out.println("子类 有参数构造" + s);
	}
}

public class Demo {
	public static void main(String[] args) {
		Fu f1 = new Fu("");
		Zi z1 = new Zi();
		Zi z2 = new Zi("123");
		
	}
}

```

## 继承中的成员方法之间的关系

1. 如果父类方法名和子类方法名不一致，直接根据不同的方法名访问即可
2. 如果父类方法名和子类方法名一致，父类方法被覆盖，叫做重写。

## 方法的重写

在继承关系中，方法名相同，参数列表相同，与返回值类型有关

方法重写的注解：@override 这个注解可以帮助我们检查是否符合重写的规则

注意：

父类的私有成员方法不能被重写

子类重写父类方法的时候，方法的权限不能比父类的方法权限更低(至少保持一致)

重写现象发生后就只能访问重写之后的内容了，但是可以用super来访问父类中的方法

## 方法重写和方法重载的区别

方法的重写(@Override)：在继承关系中，方法名相同，参数列表也相同，与返回值类型有关

方法的重载(@Overload)：在同一个类中，方法名相同，参数列表不同，与返回值类型无关。

参数列表不同的情况：个数、类型、位置

# 代码块

代码块就是使用大括号括起来的内容，根据声明位置及修饰符的不同，可以分为以下几类：局部代码块、构造代码块、静态代码块、同步代码块

## 局部代码块

就是声明在**方法内部**的，用来限定变量的声明周期，用完之后可以及时回收，提高了内存的利用率。

注意：

1. 如果变量是声明在方法内部，但是在局部代码块外部的话，那么局部代码块结束之后，变量还可以继续使用。
2. 如果变量是声明在局部代码块内部的话，那么局部代码块结束之后，变量就不能使用了。

```java
package top.zunmx.pm;

// ALC-Master
class Pot {
	public void test() {
//		int a = 3;
		{
			int a = 3; //如果在上面定义，则这个就冲突了
			System.out.println(a);
		}
//		System.out.println(a); //无法访问，代码块执行完就销毁了。
	}
}

public class Demo {
	public static void main(String[] args) {
		Pot p = new Pot();
		p.test();
	}
}

```

## 构造代码块

**放在类中**，和其他方法是平级关系，在构造方法之前执行，对构造方法中重复性的内容进行提取执行，在构造方法之前执行。

注意：

1. 构造代码块也是不需要我们手动调用，是由jvm虚拟机自动调用
2. 执行构造方法的时候，所有的构造代码块都会先执行。
3. 执行一次构造方法的时候，会把所有的构造代码块都执行了

## 静态代码块

**也是放在类中**，和其它方法平级关系。并且构造代码块是用static修饰的。

注意：

1. 静态代码块会在构造代码块之前执行。
2. 静态代码块只执行一次，不管你new几个对象。{因为静态代码块跟着类走的，类只加载了一次，所以只会执行一次，当你把程序关闭重新打开的时候，重新加载类，那么就还会执行一次静态块中的内容}

```java
package top.zunmx.pm;

// ALC-Master
class Pot {
	{
		System.out.println("构造代码块1");
	}
	static {
		System.out.println("静态代码块1");
	}

public Pot() {
		System.out.println("构造方法,无参数");

}

public Pot(String s) {
		System.out.println("构造方法,有参数");

}

public void test() {
		System.out.println("方法");
		{
			System.out.println("局部代码块1");
		}
	}

static {
		System.out.println("静态代码块2");
	}
	{
		System.out.println("构造代码块2");
	}
}

public class Demo {
	public static void main(String[] args) {
		Pot p = new Pot();
		System.out.println("-------------");
		p.test();
		System.out.println("<<<<<<<<<<<<<<<<|");
		Pot p1 = new Pot("22");
		System.out.println("-------------");
		p1.test();
		System.out.println("<<<<<<<<<<<<<<<<|");

}
}

```

# final关键字

final关键字是最终的意思，可以修饰变量、方法、类。

修饰变量：

- 变量变成了常量，在使用之前必须进行初始化。

初始化：

- 在构造方法中进行初始化
- 直接进行显示初始化
- 在构造代码块中初始化

注意：

1. 常量在程序运行过程中不能被修改，常量是一个固定的数据，定好之后使用就可以了。
2. 既然是固定的数据，方便去调用，那么它的权限一般都是最大的public
3. 最好也设置为静态，这样可以直接通过类名调用
4. 符合常量的命名规范：所有单词都是大写，中间用下划线分割

```java
class Test {
	final int a; // 成员变量，显式初始化。
	public Test() {
		a = 5;
	}
	{
		a = 10;
	}
	//只能选一种
}
```

修饰方法：

被final修饰的方法不能被重写

修饰类：

被final修饰的类不能被继承

# Eclipse进阶

内容辅助键

```
alt + /
如果上面有数组         for遍历数组
如果是main            生成主入口
如果是fore            增强for

ctrl + n             新建快捷键
ctrl + d             删除一行
ctrl + /             添加或删除注释
ctrl + shift + c     添加或删除注释
ctrl + shift + /     添加多行注释
ctrl + shift + \     取消多行注释
ctrl + alt + ↓       向下复制一行
ctrl + alt + ↑       向上复制一行
alt + ↑              代码向上移动
alt + ↓              代码向下移动
ctrl + shift + o     自动导入包
alt + shift + r      重命名
ctrl + 1             快速修复
ctrl + shift + f     代码格式化
alt + shift + s      构造方法以及get/set等等
alt + shift + l 	 生成变量
```

# 内部类

放在了内部的类，这个内部可以是类，也可以是方法

## 分类

### 按照声明位置的不同分类

成员内部类

- 普通的成员内部类
- 私有的成员内部类
- 静态的成员内部类

局部内部类

### 按照有无名字的不同

+ 有名字的内部类
+ 匿名内部类[重难点]

## 普通成员内部类

```java
class Outer{ //外部类
	class Inner{ //普通的成员内部类		
	}
}
```

访问特点：

+ 内部类成员可以访问外部成员
+ 外部类不能直接访问普通内部类成员
+ 外部类之外访问内部类？
  + 可以在外部类之外创建一个内部类的对象，然后通过内部类的对象访问内部类的成员即可。
  + 格式：外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

```java
package top.zunmx.pm2;

// ALC-Master
class Outer { // 外部类
	int a = 11;
	private int b = 2;
	class Inner { // 普通的成员内部类
		int a = 1;
		int c = 3;
		{
			System.out.println(a);
			System.out.println(b);
		}
	}
	public void test() {
//		System.out.println(c); //外部类不能访问普通内部类成员
		Inner i = new Inner();
		System.out.println(i.c);
	}
}

public class Demo {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		System.out.println(oi.c);
		Outer o = new Outer();
		Outer.Inner i = o.new Inner();
		
	}
}
```

## 私有的成员内部类

```java
class Outer{ //外部类
	private class Inner{ //普通的成员内部类		
	}
}
```

和普通的成员内部类一样，只不过用了private修饰

访问特点：

1. 私有的成员内部类可以访问外部类的成员，包括私有成员

因为私有的成员内部类都是外部类的成员，并没有超出外部类的范围

2. 外部类能不能直接访问内部类成员，但是可以先创建内部类的对象，然后简介的访问内部类的成员

3. 外部类之外如何访问内部类成员？

先在外部类中定义一个公共的方法，在此方法中创建内部类的对象并访问。外部类之外访问的时候，就可以先创建外部类的对象，然后通过外部类的对象调用这个而公共的 方法来简介的访问内部类的成员。

```java
package top.zunmx.pm2;

// ALC-Master
class Outer1 {
	int a = 10;
	int b = 20;

private class Inner {
		int c = 3;

public void show() {
			System.out.println(a);
			System.out.println(b);
			System.out.println("内部类方法");
		}
	}

public void test() {
//		System.out.println(c); // 访问不了
		Inner i = new Inner();
		System.out.println(i.c);
	}
	public void innerShow() {
		Inner i = new Inner();
		i.show();
	}
}

public class Demo2 {
	public static void main(String[] args) {
		Outer1 o = new Outer1();
		o.innerShow();
	}
}

```

## 静态的成员内部类

和普通的成员内部类一样，只不过用static修饰了

特点：

1. 静态的成员内部类只能访问外部类的静态成员

2. 外部类不能直接访问静态的成员内部类的成员，但是可以先创建内部类的对象，然后间接的进行访问内部类的成员

3. 外部类之外如何访问内部类的成员？

格式：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

- 如果静态成员内部类的成员都是非静态的，那么必须通过对象名访问这些非静态的成员。
   - 如果静态成员内部类的成员是静态的，那么可以直接通过外部类名.内部类名.成员;

```java
package top.zunmx.pm2;
// ALC-Master
class Outt{
	int a = 1;
	private static int b = 2;
	static class Inner{
		int c=33;
		static int d = 44;
		public void show() {
			System.out.println(b);
		}
		public static void aa() {
			System.out.println("In");
		}
	}
	public void test() {
//		System.out.println(c);
		System.out.println(new Inner().c);
	}
	public static void aa() {
		System.out.println("Out");
	}
}
public class D3 {
public static void main(String[] args) {
	Outt.Inner o = new Outt.Inner();
	Outt.aa();
	Outt.Inner.aa();
}
}

```

## 局部内部类

```java
class Outer{
	public void test() {
		class Inner{
			
		}
	}
	
}
```

访问特点：

1. 局部内部类可以访问外部类的成员，包括私有成员
2. 外部类不能访问直接访问内部类的成员，但是可以在局部内部类所在的方法中先创建一个局部内部类的对象，通过这个对象来访问局部内部类的成员。

```java
package top.zunmx.pm3;

// ALC-Master
class Outer {
	private int a = 11;
	int b = 22;

public void test() {
		class Inner {
			int c = 3;

public void show() {
				System.out.println(a);
			}
		}
		Inner a = new Inner();
		System.out.println(a.c);
		a.show();
	}

public void aa() {
		test();
	}
}

public class Demo {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.test();
	}
}

```

# 包

包就是存放源代码或者字节码的文件夹

## 作用

1. 区分不同种类的代码

> top.zunmx.service
   >
   > top.zunmx.entity
   >
   > top.zunmx.dao
   >
   > top.zunmx.utils
   >
   > top.zunmx.servlet

2. 在不同的包中可以存放相同类名的文件

> 域名倒写		因为域名是全球唯一的表示，绝对不会重复

## 声明

```java
package 包名
```

## 使用

```java
import 包名
```

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款了昂。

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

zunmx.fans
我 www.hao123.com实名申请友链OωO
zunmx.fans
作者小小骗人，我登陆了也看不到( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
zunmx.fans
please many update 算法 (´இ皿இ｀)boke
zunmx.fans
df1/df2 df1+df2 转置，累加----*。。。...
zunmx.fans
为何无人评论？OωO

Java 入门 (八)

zmx • 2021 年 04 月 24 日

# main方法

```java
public static void main(String[] args){

# 继承

## 继承中成员变量之间的关系

如果父类的变量名和子类的变量名一致，那么有如下的访问规则：

如果变量名不一样，直接访问就好了。

```java
package top.zunmx.main;

// ALC-Master
class Fu {
	int i = 10;
	int j = 11;
	int k = 12;
}

class Zi extends Fu {
	int i = 20;
	int j = 21;

public class Demo1 {
	public static void main(String[] args) {
		new Zi().test();
	}
}
/*
i=			30
this.i=		20
super.i=	10
j=			21
k=			12
*/
```

## 继承中构造方法之间的关系

如果父类没有无参数构造方法怎么办？但是父类有带参的

```java
package top.zunmx.c1;

// ALC-Master
class Fu {
//	public Fu() {
//		System.out.println("#父类 无参数构造");
//	}
	public Fu(String s) {
		System.out.println("#父类 有参数构造" + s);
	}
}

class Zi extends Fu {
	public Zi() {
		//super("123");
		System.out.println("子类 无参数构造");
	}

public Zi(String s) {
		
		System.out.println("子类 有参数构造" + s);
	}
}

public class Demo {
	public static void main(String[] args) {
		Zi z1 = new Zi();
		Zi z2 = new Zi("123");
		
	}
}

```

```java
package top.zunmx.c1;

// ALC-Master
class Fu {
//	public Fu() {
//		System.out.println("#父类 无参数构造");
//	}
	public Fu(String s) {
		System.out.println("#父类 有参数构造" + s);
	}
}

class Zi extends Fu {
	public Zi() {
		super("123");
		System.out.println("子类 无参数构造");
	}

public Zi(String s) {
		this();
		System.out.println("子类 有参数构造" + s);
	}
}

public class Demo {
	public static void main(String[] args) {
		Fu f1 = new Fu("");
		Zi z1 = new Zi();
		Zi z2 = new Zi("123");
		
	}
}

```

## 继承中的成员方法之间的关系

1. 如果父类方法名和子类方法名不一致，直接根据不同的方法名访问即可
2. 如果父类方法名和子类方法名一致，父类方法被覆盖，叫做重写。

## 方法的重写

在继承关系中，方法名相同，参数列表相同，与返回值类型有关

方法重写的注解：@override 这个注解可以帮助我们检查是否符合重写的规则

注意：

父类的私有成员方法不能被重写

子类重写父类方法的时候，方法的权限不能比父类的方法权限更低(至少保持一致)

重写现象发生后就只能访问重写之后的内容了，但是可以用super来访问父类中的方法

## 方法重写和方法重载的区别

方法的重写(@Override)：在继承关系中，方法名相同，参数列表也相同，与返回值类型有关

方法的重载(@Overload)：在同一个类中，方法名相同，参数列表不同，与返回值类型无关。

参数列表不同的情况：个数、类型、位置

# 代码块

代码块就是使用大括号括起来的内容，根据声明位置及修饰符的不同，可以分为以下几类：局部代码块、构造代码块、静态代码块、同步代码块

## 局部代码块

就是声明在**方法内部**的，用来限定变量的声明周期，用完之后可以及时回收，提高了内存的利用率。

注意：

```java
package top.zunmx.pm;

public class Demo {
	public static void main(String[] args) {
		Pot p = new Pot();
		p.test();
	}
}

```

## 构造代码块

**放在类中**，和其他方法是平级关系，在构造方法之前执行，对构造方法中重复性的内容进行提取执行，在构造方法之前执行。

注意：

## 静态代码块

**也是放在类中**，和其它方法平级关系。并且构造代码块是用static修饰的。

注意：

```java
package top.zunmx.pm;

// ALC-Master
class Pot {
	{
		System.out.println("构造代码块1");
	}
	static {
		System.out.println("静态代码块1");
	}

public Pot() {
		System.out.println("构造方法,无参数");

}

public Pot(String s) {
		System.out.println("构造方法,有参数");

}

public void test() {
		System.out.println("方法");
		{
			System.out.println("局部代码块1");
		}
	}

static {
		System.out.println("静态代码块2");
	}
	{
		System.out.println("构造代码块2");
	}
}

}
}

```

# final关键字

final关键字是最终的意思，可以修饰变量、方法、类。

修饰变量：

- 变量变成了常量，在使用之前必须进行初始化。

初始化：

- 在构造方法中进行初始化
- 直接进行显示初始化
- 在构造代码块中初始化

注意：

```java
class Test {
	final int a; // 成员变量，显式初始化。
	public Test() {
		a = 5;
	}
	{
		a = 10;
	}
	//只能选一种
}
```

修饰方法：

被final修饰的方法不能被重写

修饰类：

被final修饰的类不能被继承

# Eclipse进阶

内容辅助键

```
alt + /
如果上面有数组         for遍历数组
如果是main            生成主入口
如果是fore            增强for

# 内部类

放在了内部的类，这个内部可以是类，也可以是方法

## 分类

### 按照声明位置的不同分类

成员内部类

- 普通的成员内部类
- 私有的成员内部类
- 静态的成员内部类

局部内部类

### 按照有无名字的不同

+ 有名字的内部类
+ 匿名内部类[重难点]

## 普通成员内部类

```java
class Outer{ //外部类
	class Inner{ //普通的成员内部类		
	}
}
```

访问特点：

```java
package top.zunmx.pm2;

## 私有的成员内部类

```java
class Outer{ //外部类
	private class Inner{ //普通的成员内部类		
	}
}
```

和普通的成员内部类一样，只不过用了private修饰

访问特点：

1. 私有的成员内部类可以访问外部类的成员，包括私有成员

因为私有的成员内部类都是外部类的成员，并没有超出外部类的范围

2. 外部类能不能直接访问内部类成员，但是可以先创建内部类的对象，然后简介的访问内部类的成员

3. 外部类之外如何访问内部类成员？

```java
package top.zunmx.pm2;

// ALC-Master
class Outer1 {
	int a = 10;
	int b = 20;

private class Inner {
		int c = 3;

public void show() {
			System.out.println(a);
			System.out.println(b);
			System.out.println("内部类方法");
		}
	}

public void test() {
//		System.out.println(c); // 访问不了
		Inner i = new Inner();
		System.out.println(i.c);
	}
	public void innerShow() {
		Inner i = new Inner();
		i.show();
	}
}

public class Demo2 {
	public static void main(String[] args) {
		Outer1 o = new Outer1();
		o.innerShow();
	}
}

```

## 静态的成员内部类

和普通的成员内部类一样，只不过用static修饰了

特点：

1. 静态的成员内部类只能访问外部类的静态成员

2. 外部类不能直接访问静态的成员内部类的成员，但是可以先创建内部类的对象，然后间接的进行访问内部类的成员

3. 外部类之外如何访问内部类的成员？

格式：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

```

## 局部内部类

```java
class Outer{
	public void test() {
		class Inner{
			
		}
	}
	
}
```

访问特点：

```java
package top.zunmx.pm3;

// ALC-Master
class Outer {
	private int a = 11;
	int b = 22;

public void test() {
		class Inner {
			int c = 3;

public void show() {
				System.out.println(a);
			}
		}
		Inner a = new Inner();
		System.out.println(a.c);
		a.show();
	}

public void aa() {
		test();
	}
}

public class Demo {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.test();
	}
}

```

# 包

包就是存放源代码或者字节码的文件夹

## 作用

1. 区分不同种类的代码

> top.zunmx.service
   >
   > top.zunmx.entity
   >
   > top.zunmx.dao
   >
   > top.zunmx.utils
   >
   > top.zunmx.servlet

2. 在不同的包中可以存放相同类名的文件

> 域名倒写		因为域名是全球唯一的表示，绝对不会重复

## 声明

```java
package 包名
```

## 使用

```java
import 包名
```

Java 入门 (八)

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款了昂。

Typecho 插件开发 ZSecurity

个人空间使用规则[拟定] 23/3/9修订

企业微信-摸鱼必备，避免离开状态

基于Lively wallpaper的壁纸

中公教育CTS视频下载

vipufliapc 病毒分析以查杀

MySQL id重新自增录入

基于Python的Web容器开发

FreeMarker 基本技能

2023-06-14 蜜罐捕获风险报告

Java 入门 (八)

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款了昂。

Java 入门 (八)

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款了昂。