Java基础系列（十一）关键字、内部类、修饰符

一、final关键字

（1）final 修饰的类不可以被继承，但是本身可以继承其他类

class Yy {}
final class Fu extends Yy{}   // 可以继承 Yy 类
class Zi extends Fu{}        // 不能继承 Fu 类

（2）final 修饰的方法，子类可以继承但是不可以做重写
（3）final 修饰的变量称为常量，这些变量只能赋值一次

final int i = 20;
i = 30;   // 赋值报错，final 修饰的变量只能赋值一次

（4）引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改

final Person p = new Person();
Person p2 = new Person();
p = p2;    // final修饰的变量 p，所记录的地址值不能改变
p.name = "小明";// 可以更改 p 对象中 name 属性值

（5）修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值)

class Demo {
	// 直接赋值
	final int m = 100;
	
	// final 修饰的成员变量，需要在创建对象前赋值，否则报错。
	final int n; 
	public Demo(){
		// 可以在创建对象时所调用的构造方法中，为变量 n 赋值
		n = 2016;
	}
}

二、static关键字

2.1、static特点

（1）被 static 修饰的成员变量属于类，不属于这个类的某个对象。

class Demo {
	public static int num = 100;
}

class Test {
	public static void main(String[] args) {
		Demo d1 = new Demo();
		Demo d2 = new Demo();
		d1.num = 200;
		System.out.println(d1.num); // 结果为 200
		System.out.println(d2.num); // 结果为 200
	}
}

（2）被 static 修饰的成员可以并且建议通过类名直接访问。

• 类名.静态成员变量名
• 类名.静态成员方法名(参数)
• 对象名.静态成员变量名 ------不建议使用该方式，会出现警告
• 对象名.静态成员方法名(参数) ------不建议使用该方式，会出现警告

class Demo {
	// 静态成员变量
	public static int num = 100;
	// 静态方法
	public static void method(){
		System.out.println("静态方法");
	}
}
class Test {
	public static void main(String[] args) {
		System.out.println(Demo.num);
		Demo.method();
	}
}

2.2、static注意事项

（1）静态内容是优先于对象存在，只能访问静态，不能使用 this/super。静态修饰的内容存于静态区。

class Demo {
	// 成员变量
	public int num = 100;
	// 静态方法
	public static void method(){
		// this.num; 不能使用 this/super。
		System.out.println(this.num);
	}
}

（2）同一个类中，静态成员只能访问静态成员

class Demo {
	// 成员变量
	public int num = 100;
	// 静态成员变量
	public static int count = 200;
	// 静态方法
	public static void method(){
		//System.out.println(num); 静态方法中，只能访问静态成员变量或静态成员方法
		System.out.println(count);
	}
}

（3）main 方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。

2.3、定义静态常量

开发中，我们想在类中定义一个静态常量，通常使用 public static final 修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。

class Company {
	public static final String COMPANY_NAME = "火影忍者";
	public static void method(){
		System.out.println("一个静态方法");
	}
}

注意：

• 接口中的每个成员变量都默认使用 public static final 修饰。
• 所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名问。

三、匿名对象

匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
匿名对象的特点：
（1）创建匿名对象直接使用，没有变量名

new Person().eat()  // eat 方法被一个没有名字的 Person 对象调用了。

（2）匿名对象在没有指定其引用变量时，只能使用一次

new Person().eat(); // 创建一个匿名对象，调用 eat 方法
new Person().eat(); // 想再次调用 eat 方法，重新创建了一个匿名对象

（3）匿名对象可以作为方法接收的参数、方法返回值使用

class Demo {
	public static Person getPerson(){
		// 普通方式
		// Person p = new Person();	
		// return p;
		
		// 匿名对象作为方法返回值
		return new Person(); 
	}
	public static void method(Person p){}
}

class Test {
	public static void main(String[] args) {
		// 调用 getPerson 方法，得到一个 Person 对象
		Person person = Demo.getPerson();
		
		// 调用 method 方法
		Demo.method(person);
		// 匿名对象作为方法接收的参数
		Demo.method(new Person());
	}
}

四、内部类

将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

class 汽车 {       //外部类
	class 发动机 { //内部类
	}
}

内部类分为成员内部类与局部内部类。我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。
（1）成员内部类
成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问。
定义格式：

class 外部类 { 
	修饰符 class 内部类 {
		// 其他代码
	}
}

访问方式：

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

成员内部类代码演示：
定义类：

class Body {      // 外部类，身体
	private boolean life = true; // 生命状态
     public class Heart { // 内部类，心脏
		 public void jump() {
	         System.out.println("心脏噗通噗通的跳")
				System.out.println("生命状态" + life); // 访问外部类成员变量
			}
		}
	}
}

访问内部类：

public static void main(String[] args) {
	// 创建内部类对象
	Body.Heart bh = new Body().new Heart();
	// 调用内部类中的方法
	bh.jump();
}

（2）局部内部类
局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
定义格式：

class 外部类 { 
	修饰符 返回值类型 方法名(参数) {
	class 内部类 {
		// 其他代码
		}
	}
}

访问方式：
在外部类方法中，创建内部类对象，进行访问。
局部内部类代码演示：
定义类：

class Party {              // 外部类，聚会
	// 吹气球方法
	public void puffBall(){
		class Ball {      // 内部类，气球
              public void puff(){
			     System.out.println("气球膨胀了");
			  }
		}
		// 创建内部类对象，调用puff方法
		new Ball().puff();
	}
}

访问内部类：

public static void main(String[] args) {
	// 创建外部类对象
	Party p = new Party();
	// 调用外部类中的 puffBall 方法
	p.puffBall();
}

内部类的实际使用——匿名内部类
定义的匿名内部类有两个含义：

1. 临时定义某一指定类型的子类
2. 定义后即刻创建刚刚定义的这个子类的对象
   定义格式：

new 父类或接口(){
	// 进行方法重写
};

代码演示：

// 已经存在的父类：
public abstract class Person{
	public abstract void eat();
}
// 定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
Person  p = new Person(){
	public void eat() {
		System.out.println(“我吃了”);
	}
};
// 调用 eat 方法
p.eat();

使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。

五、访问修饰符

六、代码块

构造代码块
特点：

1. 优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
2. 每创建一个对象均会执行一次构造代码块。

public class Person {
	private String name;
	private int age;
	
     // 构造代码块
	{
		System.out.println("构造代码块执行了");
	}
	Person(){
		System.out.println("Person无参数的构造函数执行");
	}
	Person(int age){
		this.age = age;
		System.out.println("Person（age）参数的构造函数执行");
	}
}
class PersonDemo{
	public static void main(String[] args)	{
		Person p = new Person();
		Person p1 = new Person(23);
	}
}

静态代码块
特点：

1. 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
2. 该类不管创建多少对象，静态代码块只执行一次。
3. 可用于给静态变量赋值，用来给类进行初始化。

public class Person {
	private String name;
	private int age;
     // 静态代码块
	static{
		System.out.println("静态代码块执行了");
	}
}

---

博主的所有博客目录如下：博客文章目录汇总
Java面试部分的博客目录如下：Java笔试面试目录

转载请标明出处，原文地址：https://blog.youkuaiyun.com/weixin_41835916 如果觉得本文对您有帮助，请点击顶支持一下，您的支持是我写作最大的动力，谢谢。