匿名对象 内部类 包 访问修饰符 代码块

匿名对象：创建对象时，只有创建语句，没有把地址赋给某个变量

格式：new person()

只能使用一次，可以作为返回值 形参使用

package com.oracle.Demo03;

public class Person {
     private String name;
     private int age;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public boolean compare(Person p){
        return this.age==p.age;
    }
    //匿名对象作为返回值传递
    public Person getPerson(){
        return new Person();
    }
}

package com.oracle.Demo03;

public class Test {
     public static void main(String[] args) {
         //有名对象
        Person p = new Person();
        p.setName("zhangsan");
        p.setAge(18);
        //匿名对象 只能调用一次
        new Person().setName("aaa");
        new Person().getName();//null
        //匿名对象作为形参传递
        p.compare(new Person());
        
    }
}

内部类：将类写在其它类的内部，可以是成员位置（成员内部类）也可以是局部位置（局部内部类）

汽车类包含发动机类这种情况就可以使用内部类

成员内部类：

格式   public class Car{

                     private String color;

                     class gulu{

                 }

}

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

package com.oracle.Demo03;

public class Car {
     private String color = "红色";
     int num = 0;//Car.this.num
     //内部类（可以访问外部类的成员）
     public class Fadongji{
         int num = 3;//this.num
         public void show(){
             int num = 6;//num
             System.out.println(color);
         }
     }
}

package com.oracle.Demo03;

public class Demo {
    public static void main(String[] args) {
        //内部类访问
        Car.Fadongji cf = new Car().new Fadongji();
        cf.show();
        //局部内部类访问
        Audo a =new Audo();
        a.show();
    }
}

局部内部类：

格式   public class Car{

                   private String color;

                   public void show(){

                           class gulu{

                                  public void run(){

                                              }

                                       }

                    gulu g = new gulu();

                    g.run();

                                 }

}

访问方式：在定义内部类的成员方法中，新建一个对象，用对象去调用方法，最后 Car c = new Car(); c.show;调用局部内部类的方法

package com.oracle.Demo03;

public class Audo {
    //局部内部类
    public void show(){
        class gulu{
            public void method(){
                System.out.println("这是咕噜的方法");
            }
        }
        gulu g = new gulu();
        g.method();
    }
}

package com.oracle.Demo03;

public class Demo {
    public static void main(String[] args) {
        //内部类访问
        Car.Fadongji cf = new Car().new Fadongji();
        cf.show();
        //局部内部类访问
        Audo a =new Audo();
        a.show();
    }
}

匿名内部类：创建的是某一指定类型的子类 定义后即刻创建

格式：new 父类或接口（）{

重写方法 因为现在创建的是子类；

}

package com.oracle.Demo03;

public interface Jidu {
    public abstract void run();
}

package com.oracle.Demo03;

public class JiduDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //匿名内部类的使用
        new Jidu(){
            public void run(){
                System.out.println("Jidugou");
            }
        }.run();
    }

}

包：文件夹

格式：package  包名.包名.包名...;

必须在有效代码的第一行

访问包里面的类：包名.包名...类名；

导包：import

访问修饰符

public :本类   同一包（子类和无关类）  不同包的子类  不同包的无关类

protected:本类  同一包（子类和无关类）  不同包的子类

default---什么也不写的时候：本类  同一包（子类和无关类）

private:本类

java文件中只能有一个public类，并且文件名要和类名一致

代码块：以{}划定边界，类和方法都是以代码块的方式划定边界的

构造代码块：{} 在成员变量的位置  建一个对象，执行一次

静态代码块：static{} 在成员变量的位置  在第一次建对象时执行一次 最先执行

局部代码块：定义在方法和语句中 调用多次