JAVA学习笔记（九）

匿名对象

1.1匿名对象的概念

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

　　如，创建一个普通对象

Person p = new Person();

　　创建一个匿名对象

new Person();

1.2匿名对象的特点

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

内部类

2.1内部类的概念

　　将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

　　内部类分为成员内部类与局部内部类。

2.2成员内部类

　　定义格式

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

　　访问格式

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

2.3局部内部类

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

定义格式

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

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

2.4匿名内部类

　　最常用到的内部类就是匿名内部类，它是局部内部类的一种。

　　匿名内部类的作用：简化代码。

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

public class Test {
    Function f=null;
    public static void main(String[] args) {
        smoking s=new smoking(){
            public void smoke() {
                System.out.println("猴子抽烟");        
            }
        }.smoke();
    }
}

包的声明与访问

　　Java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。

3.1包的声明格式

package 包名.包名.包名…;

3.2包的访问

　　在访问类是，为了能找到该类，必须使用含有包名的类全名（包名、类名）。

3.3import导包　

　　导包的格式：

import 包名.类名;

　　当程序员导入指定的包后，使用类时，就可以简化了

//导入包前的方式
//创建对象
java.util.Random r1 = new java.util.Random();
java.util.Random r2 = new java.util.Random();
java.util.Scanner sc1 = new java.util.Scanner(System.in);
java.util.Scanner sc2 = new java.util.Scanner(System.in);

//导入包后的方式
import java.util.Random;
import java.util.Scanner;
//创建对象
Random r1 = new Random();
Random r2 = new Random();
Scanner sc1 = new Scanner(System.in);
Scanner sc2 = new Scanner(System.in);

访问修饰符

　　在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：

　　归纳：

　　要想仅能在本类中访问使用private修饰；

　　要想本包中的类都可以访问不加修饰符即可；

　　要想本包中的类与其他包中的子类可以访问使用protected修饰

　　要想所有包中的所有类都可以访问使用public修饰。

　　注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

代码块

4.1局部代码块

　　局部代码块是定义在方法或语句中

特点：

　　1.以”{}”划定的代码区域，此时只需要关注作用域的不同即可

　　2.方法和类都是以代码块的方式划定边界的

class Demo{
    public static void main(String[] args)    {
        {
                  int x = 1;
                 System.out.println("普通代码块" + x);
        }
        int x = 99;
        System.out.println("代码块之外" + x);
    }
}
//运行结果：普通代码块1
//代码块之外99

4.2构造代码块

　　构造代码块是定义在类中成员位置的代码块。

特点：

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

4.3静态代码块

　　静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

　　1.它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

　　2.该类不管创建多少对象，静态代码块只执行一次。

　　3.可用于给静态变量赋值，用来给类进行初始化。

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