2019-05-30 java学习日记

面向对象

四种权限修饰符

private，默认，protected,public

1，其中private的权限最小，只能在本类中访问

2，其次是默认，类名，构造方法前什么都不打，
可以在本类中和同一个包下（子类和无关类）中访问

3，然后是protected，可以在可以在本类，
同一个包下（子类和无关类），不同包下的子类中访问

4，最后是public，public的访问权限最大，
可以在可以在本类，同一个包下（子类和无关类），
不同包下的子类与不同包下的无关系类中访问

 

 

类及其组成所使用的常见修饰符

修饰符

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

类

权限修饰符：默认修饰符，public

状态修饰符：final

抽象修饰符：abstract

用的最多的是：private

成员变量

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

用的最多的是：private

构造方法

权限修饰符：private，默认的，protected，public

用的最多的是：public

成员方法

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

用的最多的是：public

除此之外的组合规则

成员变量：public static final 接口

成员方法：

public static

public abstract

public final

 

 

内部类的概述

在类中定义类，这就是叫做内部类

内部类的访问特点

1，内部类可以直接访问外部类的成员，包括私有

2，外部类要访问内部类的成员，必须创建对象

3，外部类名.内部类名  对象名  = 外部类对象.内部类对象;
如：Outer.Inter oi = new Outer().new Inter();

class  demo1_innerclass {
    public static void main (String args []) {
       //外部类访问内部类时一定要创建对象
    outer.inner oi=new outer().new inner();
        oi.method();
    }
}
class outer {
    private int num=20; 
        class inner {       //内部类可以直接访问外部类
            public void method() {
            System.out.println(num);
        }
    }
}          

 

 

成员内部类私有使用

class Demo_Inner {
    public static void main(String[] args) {

        Outer o = new Outer();
        o.method();    
        }
}

class Outer {
   private int numb = 20;
    private class Inner {
         public void print() {
            System.out.println(numb);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.print();
     }
}    

内部类私有，在外部类创建一方法，在方法里创建一个对象进行调用。

注：//outer.inner oi=new outer().new inner();
　　//oi.method();
这种情况下就不能使用这种方法

 

 

静态成员内部类

class  demo2_Inner {
    public static void main (String args []) {
        //外部类名.内部类名 对象名 = 外部类名.内部类对象
    Outer.Inner oi = new Outer.Inner();
    oi.method();

    Outer.Inner2.print();
    }
}
class Outer {
        static class Inner {
            public void method() {
                System.out.println("啦啦啦");
        }
    }
    static class Inner2{
        public  static void print(){
            System.out.println("哇哈哈");
        }
    }
}

注：Outer.Inner oi = new Outer.Inner();
其次是外部类名. new内部类名，
只是我们习惯把new放在最前面，
所以是 new Outer.Inner(); 

 

 

局部内部类

class  demo1_Innerclass {
    public static void main (String args []) {
    Outer o = new Outer();
    O.print();
    }
}
class Outer {
　　　　final int a = 10;
    public void print() {
    class Inner{
        public void method() {
        System.out.println("喵喵喵？");
        }
    }
    Inner i = new Inner();  
    I.method();
    }
}

注：局部内部类只能在本类方法去访问,运行完就会被弹栈，
所以局部内部类在访问他所在的方法中的局部变量必须用final修饰，使其变为常量，
方法弹栈后，常量会存在方法区的常量池

为什么局部内部类在访问他所在方法中的局部变量必须用final修饰？

因为当调用这个方法时,局部变量如果没有用final修饰,
他的生命周期和方法的生命周期是一样的,当方法弹栈,
这个局部变量也会消失,那么如果局部内部类对象还没有马
上消失想用这个局部变量,就没有了,如果用final修饰会在类加载
的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

注：但是jdk1.8取消了这个事情,所以我认为这是个bug,虽然取消,
但是如果在书写代码的时候,没有手动添加,系统底层也会默认给你final

 

 

匿名内部类

匿名内部类就是内部类的简化写法（没有名字的内部类）

前提：必须存在在一个类或者接口

　　这里的类视具体类也可以是抽象类

格式

　　new 类名或者接口名（）{

　　　　重写方法：

}

new一个类 ，就代表是继承这个接口，
而new一个接口，那就是实现这个接口
本质就是一个继承了该类或者实现了该接口的子类匿名对象

 

注：1，匿名内部类是局部内部类的一类，只能写在方法里！
2，匿名内部类只针对重写一个方法时使用，超过一个方法不建议用了
3，匿名内部类是不能向下转型的 ，因为没有子类类名

class Demo_NoNameInner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

interface Inter {
    public  void print();
}

class Outer {
    class Inner    implements Inter {
        public void print() {
            System.out.println("哇哈哈");
        }
    }

    public void method() {
        new Inner().print();            //这个其实跟以下的整一块差不多
        new Inter() {                //实现Inter接口
            public void print() {        //重写抽象方法
                System.out.println("喵喵喵");
    }
}.print();              //调用子类对象里面的方法                
                              //这一块整个代表Inter的子类对象

    }
    
}