final关键字、static关键字、匿名对象与内部类

古城微笑少年丶 2022-05-26 23:08 162阅读 0赞

final关键字 有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。这时需要用到一个关键字final，final的意思为最终，不可变。

final是个修饰符，可以用来修饰类，类的成员，以及局部变量。

final修饰类不可以被继承，但是可以继承其他类

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

final修饰的方法不可以被覆盖，但父类中没有被final修饰方法，子类覆盖后可以加final。

class Fu {
    	// final修饰的方法，不可以被覆盖，但可以继承使用
        public final void method1(){}
        public void method2(){}
    }
    class Zi extends Fu {
    	//重写method2方法
    	public final void method2(){}
    }

final修饰的变量称为常量，这些变量只能被赋值一次。

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

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

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

修饰成员变量，需要在创建对象前赋值，否则报错。

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

static关键字 当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。不创建对象方法又调用不了。可以通过static关键字来实现不创建对象就可以调用方法。

static是静态修饰符，一般用来修饰类中的成员。

被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个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
    	}
    }

被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();
    	}
    }

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

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

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

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

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

定义静态常量  通常使用public static final 修饰的变量 来完成静态常量的定义。此时变量名用全部大写，多个单词使用下划线连接。定义格式： public static final 数据类型 变量名 = 值；

class Company {
    	public static final String COMPANY_NAME = "红后科技";
    	public static void method(){
    		System.out.println("一个静态方法");
    	}
    }

当想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。

System.out.println(Company.COMPANY_NAME); //打印“红后科技”
    Company.method(); // 调用一个静态方法

注意：接口中的每个成员变量都默认使用public static final 修饰。

所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。

interface Inter {
    	public static final int COUNT = 100;
    }
    
    //访问接口中的静态变量
    Inter.COUNT

匿名对象  匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

已经存在的类：

public class Person{
    	public void eat(){
    		System.out.println();
    }
    }

创建一个普通对象：

Person p = new Person();

创建一个匿名对象：

new Person();

匿名对象的特点

创建匿名对象直接使用，没有变量名。

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

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

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

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

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 发动机 { //内部类
    }
    }

内部类分为成员内部类与局部内部类。定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。 在内部类中可以直接访问外部类的所有成员。

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

定义格式：

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

访问方式：外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

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

定义格式：

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

访问方式： 在外部类方法中，创建内部类对象，进行访问