【21天学习挑战赛—Java编程进阶之路】(6)

​
​

活动地址：CSDN21天学习挑战赛

学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：
想系统/深入学习某技术知识点…
一个人摸索学习很难坚持，想组团高效学习…
想写博客但无从下手，急需写作干货注入能量…
热爱写作，愿意让自己成为更好的人…
…
个人名片：

🐼作者简介：一名大一在校生
🐻‍❄️个人主页：小新爱学习.
🐼个人WeChat：hmmwx53
🕊️系列专栏：零基础学java ----- 重识c语言
🐓每日一句：人生没有一劳永逸，想不被抛弃，只有自己努力

---

创作计划

**
1，机缘

我是一名普二学生，由于疫情原因大一下班学期也是没有开学，不甘堕落于是在互联网这片汪洋大海中，摸寻着前进的方向，也是偶然的机会接触到了CSDN，在这里有一群志同道合的朋友一起努力，于是自己也加入了进了，一篇两篇，也收获了很多的粉丝，推动着我前进…

2，收获

在CSDN这个大家庭里，每天都过得很充实，尤其是有不错的粉丝量，文章上了热榜，都会让我高兴半天，也结识了很多优质博主，像凉哥，哪吒…

3，日常

创作已经成为记录生活的一部分了，这里有我成长的点滴…

4，憧憬

有朝一日我也能成为优质博主，有自己的铁粉团队…

**

学习计划

**
1，学习目标

这21天我们可以分为3周，每周更新三篇

2，学习内容

• 第二周：周一
• 面向对象，
• 包括面向对象三大特征，
• 关键字private，this
  第二周：周三
• 方法重载与重写
• static关键字
• 权限修饰符，
• 常量，
  第二周： 周六
• 抽象类，接口
• 内部类等概念！

3，学习时间
每周一，周三，周六

4，学习产出：

技术笔记每周3篇

Blink若干

学习日记

第二周：周六

静态代码块、构造代码块、局部代码块

静态代码块：只加载一次，随着类的加载而加载，一般用在项目的初始化，放在类的里边方法的外边
格式：
static{}
构造代码块：在创建对象的时候自动调用，每次创建对象都会被调用，提取构造的共性代码
局部代码块：方法里的代码块，限制局部变量的范围
执行顺序
静态代码块–>构造代码块–>构造方法–>局部代码块
为什么会是这样的顺序？
静态代码块要优先于对象加载，是随着类的加载而加载到内存中，只加载一次，并且会一直存在，直到类消失，它才会消失

成员内部类和匿名内部类

1、成员内部类（应用率极低）

在一个类中可以定义成员变量、成员方法、还可以定义类，把这个定义的类称作为成员内部类
类中套类，外面的称为Outer外部类，里面测称为Inner内部类，内部类只服务于外部类，对外不具备可见性，内部类的对象通常在外部类中创建的。
内部类可以直接访问外部类的成员（包括私有的）
内部类中有个隐式的引用指向了创建它的外部类对象
在内部类访问外部类的实例变量是：外部类名.this.属性

2、匿名内部类：没有名字的子类

格式： new 类名或者接口的名()
{ 重写方法; };

匿名内部类的前提：必须要有一个类或者一个接口，这个类可以是具体的类也可以是抽象类，相当于一个没有名字的子类去继承一个类或者实现一个接口，然后重写里边的方法
使用场景：当被调用的对象只调用一次时使用匿名内部类（多次创建多个对象浪费内存），没有名字的对象，是对象的简化形式

内部类有独立的.class吗？
答案：有

代码示例：

public class Test_InnerClass {

	public static void main(String[] args) {
		//Baby b = new Baby();//编译错误，内部类对外不具备可见性
		Mama m = new Mama();
	}
}
class Mama{
	private String name;
	void createBaby(){
		Baby b = new Baby();
	}
	class Baby{
		void showMamaName(){
			System.out.println(name);
			System.out.println(Mama.this.name);//在内部类访问外部类的实例变量是：外部类名.this.属性
			//System.out.println(this.name);//编译错误
		}
	}
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class Test_NstInnerClass {

	public static void main(String[] args) {
		/*
		 * 创建了一个Teacher的子类，但是没有名字
		 * 为该子类创建了一个对象，名为t
		 * 大括号中是子类的类体
		 */
		//通过匿名内部类来重写方法
		Teacher t = new Teacher(){
			public void teach(){
				System.out.println("我是匿名内部类");
			}
		};
		t.teach();
		//通过普通继承来重写方法
		JavaTeacher j = new JavaTeacher();
		j.teach();
	}
}

class Teacher{
	public void teach(){
		System.out.println("备课ing");
	}
}
class JavaTeacher extends Teacher{
	public void teach(){
		System.out.println("java老师在备课");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

多态

前提：继承+重写
指同一个实体同时具有多种形式
特点：

• 成员变量：使用的是父类的
• 成员方法：使用的是子类的（因为存在重写的现象）
• 静态成员：谁调用返回就是谁的（随着类的加载而加载）
• 注意：静态资源属于类，不存在重写
• 多态的好处：提高了程序的可扩展性和可维护性

接口

接口概述：

接口就是一种公共的规范标椎，只要符合规范标准，大家都可以通用
java中的接口更多的体现在对行为的抽象

接口的特点

接口用关键字interface修饰
public interface 接口名 {}

public interface Jumpping {
 public abstract void jump();
}
1
2
3

类实现接口用implements表示

public class 类名 implements 接口类 {}
1

//类和接口之间不能用继承，这里采用implements实现的意思，类实现接口
public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫猫跳的高");
    }
}
1
2
3
4
5
6
7

接口不能实例化
接口的实例化参照多态的方法，通过实现类对象实例化，这也叫做接口多态
多态的形式：具体类多态，抽象类多态，接口多态。
多态的前提：有继承或者实现关系；有方法重写；有父类（类/接口）引用指向（子/实现）类对象
接口实现类
要么重写接口中的所有抽象方法
要么是抽象类

public class JumppingDemo {
    public static void main(String[] args) {
        //接口也是抽象类，不能实例化，这里采用多态方法实例化
           Jumpping j = new Cat();
           j.jump();
    }
}
1
2
3
4
5
6
7

接口的成员特点

成员变量
只能是常量
默认修饰符：public static final
构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在一个类如果没有父类，默认继承Object类
成员方法
只能是抽象方法
默认修饰符： public abstract