一：代码块
代码块：使用{}定义的一段代码，根据代码块定义的位置以及关键字，又分为以下四种
- 普通代码块
- 实例代码块
- 静态代码块
- 同步代码块（Java多线程再说）
①：普通代码块：定义在方法中的代码块
- 此种用法很少见
public class TestDemo {
public static void main(String[] args) {
{
//普通代码块
int a = 10;
System.out.println("a = "+ a);
}
int b = 20;
System.out.println("b = "+ b);
}
}
②：实例代码块：定义在类中的代码块，一般用于初始化实例成员变量
- 下面的运行结果可以看出：实例代码块优先级高于构造方法
- 实例代码块只有在创建对象时才会执行
public class Student {
public String name;
public int age;
public Student(){
System.out.println("构造方法运行");
}
//实例代码块
{
this.name = "张三";
this.age = 18;
System.out.println("实例代码块运行");
}
public static void main(String[] args) {
Student s = new Student();
}
}
public class Student {
public String name;
public int age;
public static String classes;
public Student(){
System.out.println("构造函数运行");
}
//实例代码块
{
this.name = "张三";
this.age = 18;
System.out.println("实例代码块运行");
}
//静态代码块
static{
classes = "三年二班";
System.out.println("静态代码块运行");
}
public static void main(String[] args) {
}
③：静态代码块：使用static所修饰的代码块，用于初始化静态成员变量
- 下面的运行结果可以看出：静态代码块优先级高于实例代码块，实例代码块优先级高于构造方法
- 静态代码块不管生成多少个对象，它只会执行一次
- 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并
public class Student {
public String name;
public int age;
public static String classes;
public Student(){
System.out.println("构造函数运行");
}
//实例代码块
{
this.name = "张三";
this.age = 18;
System.out.println("实例代码块运行");
}
//静态代码块
static{
classes = "三年二班";
System.out.println("静态代码块运行");
}
public static void main(String[] args) {
Student s = new Student();
}
}
二：内部类
（1）内部类的定义
内部类：在Java中，可以将一个类定义在另一个类或一个方法内部，前者称之为内部类，后者称之为外部类。内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件
//A是外部类
//B是内部类
public class A{
class B{
}
}
（2）内部类分类
内部类分类：内部类是一个很宽泛的概念，有如下几种
- 实例内部类
- 静态内部类
- 局部内部类（了解即可）
- 匿名内部类（最常用）
A：实例内部类
实例内部类：如果没有static修饰它就是实例内部类，使用时注意以下几点
①：实例内部类当中，不能定义静态的成员变量或方法
- 其实，成员变量是可以定义的，只需加
final关键字即可；但是成员方法确实是不能定义的
②：要想实例化内部类对象必须得先有外部类对象存在。也即外部类类名.内部类 类名字 = 外部类引用.new 内部类
- 同理：外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象
class OuterClass {
public int outer_a = 1;
public int outer_b = 2;
class InnerClass{
public int inner_a = 3;
public int inner_b = 4;
}
}
public class Test{
public static void main(String[] args) {
//外部类对象必须先创建
OuterClass out = new OuterClass();
//利用外部对象实例化内部类
OuterClass.InnerClass inner = out.new InnerClass();
//注意：也可以合并写
OuterClass.InnerClass inner1 = new OuterClass().new InnerClass();
}
}
③：外部类中任何成员都可以被实例内部类中的方法直接访问
class OuterClass {
public int outer_a = 1;
public int outer_b = 2;
class InnerClass{
public int inner_a = 3;
public int inner_b = 4;
public InnerClass(){
System.out.println("实例内部类构造方法");
}
public void InnerFunc(){
System.out.println("实例内部类普通方法：" + "outer_a=" + outer_a);
}
}
}
public class Test{
public static void main(String[] args) {
//外部类对象必须先创建
OuterClass out = new OuterClass();
//利用外部对象实例化内部类
OuterClass.InnerClass inner = out.new InnerClass();
inner.InnerFunc();
}
}
④：如果实例内部类和外部类的成员同名，那么优先访问实例内部类中的成员；如果要访问外部类的同名成员，格式为外部类名称.this.同名成员
- 要访问外部类静态成员变量，则格式为：外部类名称.成员名
class OuterClass {
public int outer_a = 1;
public int outer_b = 2;
class InnerClass{
public int outer_a = 11;
public int inner_a = 3;
public int inner_b = 4;
public InnerClass(){
System.out.println("实力内部类构造方法");
}
public void InnerFunc(){
System.out.println("实例内部类普通方法：" + "outer_a=" + outer_a);
}
}
}
public class Test{
public static void main(String[] args) {
//外部类对象必须先创建
OuterClass out = new OuterClass();
//利用外部对象实例化内部类
OuterClass.InnerClass inner = out.new InnerClass();
inner.InnerFunc();
}
}
class OuterClass {
public int outer_a = 1;
public int outer_b = 2;
class InnerClass{
public int outer_a = 11;
public int inner_a = 3;
public int inner_b = 4;
public InnerClass(){
System.out.println("实力内部类构造方法");
}
public void InnerFunc(){
System.out.println("实例内部类普通方法：" + "outer_a（外部）=" + OuterClass.this.outer_a);
}
}
}
public class Test{
public static void main(String[] args) {
//外部类对象必须先创建
OuterClass out = new OuterClass();
//利用外部对象实例化内部类
OuterClass.InnerClass inner = out.new InnerClass();
inner.InnerFunc();
}
}
B：静态内部类
静态内部类：如果有static修饰它就是静态内部类，使用时注意以下几点
①：静态内部类中，自然可以定义静态的成员变量或方法
②：要实例化内部类对象，应该这样写
public class OuterClass {
public int outer_a = 1;
public int outer_b = 2;
public static int outer_static = 3;
static class InnerClass{
public int inner_a = 4;
public int inner_b = 5;
public static int inner_static;
public InnerClass(){
System.out.println("内部类构造方法");
}
}
public static void main(String[] args) {
OuterClass.InnerClass inner = new OuterClass.InnerClass();
}
}
③：静态内部类中，不能直接访问外部类的非静态成员
如果需要访问，则要提供外部类对象
public class OuterClass {
public int outer_a = 1;
public int outer_b = 2;
public static int outer_static = 3;
static class InnerClass{
public int inner_a = 4;
public int inner_b = 5;
public static int inner_static;
public void test(){
OuterClass out = new OuterClass();
System.out.println(out.outer_a);
System.out.println(out.outer_b);
}
}
public static void main(String[] args) {
OuterClass.InnerClass inner = new OuterClass.InnerClass();
inner.test();
}
}
C：局部内部类（了解即可）
局部内部类：定义在外部类的方法体或者{}中，局部内部类只能在其定义的位置使用，且不能被public等修饰，几乎不会使用
public class Test{
public static void func(){
class A{
}
}
}
D：匿名内部类
- 在接口这一部分讲解
评论区