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

我就是我 2021-09-26 13:58 274阅读 0赞

### 关键字、内部类、修饰符 ###

*  一、final关键字
 *  二、static关键字
 *   *  2.1、static特点
     *  2.2、static注意事项
     *  2.3、定义静态常量
 *  三、匿名对象
 *  四、内部类
 *  五、访问修饰符
 *  六、代码块

# 一、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();

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

# 五、访问修饰符 #

![这里写图片描述][70]

# 六、代码块 #

构造代码块  
特点：

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("静态代码块执行了");
    	}
    }

--------------------

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

> **转载请标明出处，原文地址：https://blog.csdn.net/weixin\_41835916 如果觉得本文对您有帮助，请点击顶支持一下，您的支持是我写作最大的动力，谢谢。  
> ![这里写图片描述][70 1]**

[70]: /images/20210923/c432a5b2a2e84291862dc0a5a56b5afa.png
[Link 1]: https://blog.csdn.net/weixin_41835916/article/details/81879208
[Java]: https://blog.csdn.net/weixin_41835916/article/details/81413498
[70 1]: /images/20210923/a98aae4f3061439db6a6be8b81ababb4.png