java笔记

java中有四种权限修饰符:

权限由大到小	public	protected	(default)	private
同一个类	YES	YES	YES	YES
同一个包	YES	YES	YES	NO
不同包子类	YES	YES	NO	NO
不同包非子类	YES	NO	NO	NO

内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。例如：身体和心脏的关系 又如：汽车和发动机的关系。

分类：

1.成员内部类

2.局部内部类（包含匿名内部类）

成员内部类的定义格式:

修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        //..
    }
    //..
}

注意:内用外，随意访问，外用内，需要内部类对象。

如何使用成员内部类

有两种方式: 1．间报方式:在外部类的方法当中，使用内部类，然后main只是调用外部类的方法。

1. 直接方式 公式： 类名称 对象名 = new 类名称() 【外部类名称.内部尖名称 对象名= new 外部类名称().new 内部类名称();】

public class Body {// 外部类
    public class Heart{  // 成员内部类
        //内部类的方法
        public void beat(){
            System.out.println("心脏跳动");
            System.out.println("我叫："+name);
        }
    }
    //外部类的成员变量
    private String name;
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
    //外部类的方法
    public void  methodBody(){
        System.out.println("外部类的方法");
        new Heart().beat();
    }
}

public class Dexter {
        //如何使用成员内部类?有两种方式:
    //1．间报方式:在外部类的方法当中，使用内部类，然后main只是调用外部类的方法。
    //2.直接方式 公式：
    //类名称 对象名 = new 类名称()
    //【外部类名称.内部尖名称 对象名= new 外部类名称().new 内部类名称();】
    public static void main(String[] args) {
        Body body = new Body();//外部类的对象
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();
        System.out.println("========================");
​
        //按照公式写
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

内部类的同名变量访问

//如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer {
    int num = 10;//外部类的成员变量
    public  class Inner {
        int num = 20;//内部类的成员变量
        public void methodInner(){
            int num = 30;//内部类方法的局部变量
            System.out.println(num);//局部变量，就近原则
            System.out.println(this.num);//内部类的成员变量
            System.out.println(Outer.this.num);//外部类的成员变量
        }
    }
}

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。

”局部”，只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：

修饰符 class 外部类名称 {
    修饰符  返回值类型 外部类方法名称(参数列表) {
        class 局部内部类名称{
            //..
        }
    }
}

类的权限修饰符：

public > protected > (default) > private

1.外部类: public / ( default)

2成员内部类: public / protected / ( default) / private

3.局部内部类: 什么都不能写

public class Outer {
     public void methodOuter() {
         class Inner {//局部内部类
             int num = 10;
             public void  methodInner(){
                 System.out.println(num);
             }
         }
         Inner inner = new Inner();
         inner.methodInner();
     }
}
===================================================
public class Dexter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.methodOuter();
    }
}

局部内部类的final问题

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。

备注：从java 8+开始。只要局部变量事实不变，那么final关健字可以省略。

原因:

1.new出来的对象在堆内存当中。

2．局部变量是跟着方法走的,在栈内存当中。

3．方法运行结束乏后，立刻出栈，局部变量就会立刻消失。

4．但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class Outer {
     public void methodOuter() {
         int num = 10;
         class MyInner {
             public void methodInner(){
                 System.out.println(num);
             }
         }
}

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。

那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式:

接口名称  对象名  = new 接口名称() {
    // 覆盖重写所有抽象方法
};

public interface Interface {
    public abstract void method();
}
==============================================
public class MyInterface {
    public static void main(String[] args) {
        Interface Obj = new Interface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法");
            }
        };
        Obj.method();
    }
}

匿名内部类注意事项

1.匿名内部类,在【创建对象】的时侯,只能使用唯—一次。

如果希望多次创建对象，而且类的内容一样的话。那么就必须使用单独定义的实现类了。

2.匿名对象。在【调用方法】的时候,只能调用唯——次。

如果希望同一个对象，调用多次方法,那么必须给对象起个名字。

3.匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】

强调：匿名内部类和匿名对象不是一回事！！！！！！！！