第7章类的高级特性

Posted 2021-06-14 啊...这

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了第7章类的高级特性相关的知识，希望对你有一定的参考价值。

修饰符:

1、Static修饰符

　　平时我们在调用类的属性和方法的时候,都要通过创建类对象来调用.

但是如果使用Static修饰符来修饰方法或属性,就可以直接通过类名.方法

或属性来调用,当然,也还是可以通过对象来调用.

class 类名
{
 static 数据类型 成员变量名;

 访问权限修饰符 static 返回值类型 方法名()
 {
    //方法实现
 }
}//调用 类名.方法或属性;

被static修饰的成员变量被称为静态变量

被static修饰的成员方法被称为静态方法

被static修饰的成员变量和方法不属于这个类的某个对象,而属于这个类.

当类被加载如内存的时候,就在方法区给静态成员变量创建了内存空间,并对静态成员变量进行了初始化,因此静态变量的内存空间分配比类的对象的创建早.

注意:所有的对象共享静态变量的值,当其中一个对象修改静态变量的值,其他对象访问该静态变量时,静态变量的值就是修改之后的值

,且静态方法只能访问静态变量,不能访问类中的非静态变量.

什么时候该用static修饰符来修饰成员变量和成员方法?

当想要多个对象共用一个成员变量的时候,或是想直接通过类名来调用方法和成员变量的时候.

2、Final修饰符

final修饰的类不能被继承, 但是可以继承其他类.

final修饰的方法不可以被覆盖(重写)

final修饰的变量称之为常量,只能赋值第一次.

final引用类型的变量值为对象地址值时,地址不能更改,但地址内的对象属性值可以修改.

final修饰成员变量时,需要在创建对象前赋值,否则会报错

在java程序开发中,如果想在类中定义一个静态常量,通常使用public static final修饰的变量来定义.

class Student{
public static final 数据类型 变量名=常量值;
}

注意:接口中的每个成员变量都默认使用public static final来修饰,所有接口的成员变量已经是静态常量了,由于接口没有构造方法,所以必须显示赋值.访问成员变量时可以直接用接口名访问.

代码块:

代码块大致可以分为三种:

1、局部代码块:定义在方法或语句中,就是以"{ }"划定的代码区域,方法和类都是以代码块的方式划定边界的.注意:作用域的不同

2、构造代码块:是定义在类中成员位置的代码块,比构造方法更早执行.构造代码块用于执行所有对象均需要的初始化动作,每创建一个对象均会执行一次构造代码块.

　　例子:

public class Person {
    int id;
    public Person() {//这是构造方法
        super();
        System.out.println("Person的构造方法运行");
    }

    {//这是构造代码块
        System.out.println("Person的构造代码块运行");
    }
    
    public static void main(String args[])
    {
        Person person1=new Person();//构造代码块会先比Person的构造方法早运行.
    }
    
}

运行结果:

　　Person的构造代码块运行
　　Person的构造方法运行

3、静态代码块: 是定义在成员位置中,使用static修饰的代码块.他比构造代码块还先于执行,但是他只在运行一次.当该类加载进内存块的时候,他就会运行.

作用:给静态变量赋值,对类进行初始化.

public class Person {
    int id;
    public Person() {//这是构造方法
        super();
        System.out.println("Person的构造方法运行");
    }
    {//这是构造代码块
        System.out.println("Person的构造代码块运行");
    }
    static {
        System.out.println("Person的静态代码块运行");
    }
    public static void main(String args[])
    {
        System.out.println("Person");//构造代码块会先比Person的构造方法早运行.
    }
    
}
//运行结果:
//Person的静态代码块运行
//Person

运行顺序:静态代码块<构造代码块<构造方法

匿名对象

匿名对象就是指创建对象时,只有创建对象的语句(即new 类型()),但没有把对象地址值赋值给某个变量.(只创建,不引用)

用法:

1、创建匿名对象直接用来直接调用该对象的成员变量或方法,没有引用存储该对象的地址,只能使用一次.

语法:

new Person().eat();
//new 类名(构造方法参数).方法或成员变量;

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

　例子:

public class Person {
    int id=01;
    String name="小张";
}



public class Demo {
    public static Person getPerson() {//这就是将类作为函数的返回类型
        return new Person();//将匿名类作为返回值
    }
    public static void printlnIDNAME(Person p) {
        System.out.println(p.id+" "+p.name);
    }
    public static void main(String args[])
    {
        System.out.println(Demo.getPerson());
        Demo.printlnIDNAME(new Person());//这是将匿名类作为方法的参数来使用
    }
}

运行结果:

内部类

什么是内部类?

在类的内部定义的另一个类就是内部类.而这个内部类所在的类就被称为外部类.

内部类根据位置、修饰符、定义的方式可以分为:1、成员内部类 2、方法内部类

成员内部类:

在一个类中不仅可以定义成员变量和成员方法,还可以再定义一个类

在类中定义的类就被称为成员内部类,并且在成员内部类中还可以访问外部类的所有成员(比如成员变量和成员方法),外部类无法访问内部类的成员变量和方法.并且创建出来的内部类对象只能访问内部类的成员变量和成员方法.

例子:

class bottle{//这是一个外部类
    int capacity=200;
    
    public  void printCapacity() {//外部类的方法
        System.out.println(this.capacity);
    }
    
    class water{//这是一个内部类
        String name="可乐";
        
        public void printName() {//内部类的方法
            printCapacity();//成员内部类也可以使用外部类的方法
            System.out.println(capacity+"ml的"+name);//成员内部类也可以使用外部类的成员变量
        }
    }
    
    public void demo1(){
        
        new water().printName();//虽然外部类无法直接访问内部类的方法和成员变量,但可以通过在方法里创建内部类的类型的对象来调用
    }
    
}
public class demo {
    public static void main(String args[])
    {
        bottle.water b1=new bottle().new water(); 
        //成员内部类的引用:外部类名.内部类名 变量名=new 外部类名(构造参数).内部类名(构造参数); 
        b1.printName();//内部类类型的变量只能够调用内部类的方法和参数
        String name=b1.name;
        bottle b2=new bottle();
        b2.demo1();
        
    }
}

运行结果:

200
200ml的可乐
200
200ml的可乐

特点:

内部类是在类内部定义的类.

内部类中可以直接访问外部类的成员变量和方法,但外部类中想要访问内部类中的成员,就得创建对象来访问(或者设置为静态来通过类名.成员来访问).

创建内部类对象的方式和平时创建普通类的对象方式不同.

外部类.内部类 变量名= new 外部类(构造参数).new 内部类(构造参数);

方法内部类:

方法内部类,顾名思义就是定义在方法内部的类,但是他只能在当前方法中使用.

例子:

public class Demo1{
    public void printNum()
    {
        class Num {//这就是在printNum方法中的方法内部类Num
            int num=10;
        }
        System.out.println(new Num().num);//只有这个方法才能访问Num类
    }
    public static void main(String args[])
    {
        Demo1 demo = new Demo1();
        demo.printNum();
    }

}