面向对象-封装继承多态 抽象类 接口 内部类

四种权限控制符：

private ：private修饰的成员变量只能在本类访问，其他类要访问只能用get和set方法

default：

相同包内能相互访问

protected：

只要是它的子类就能直接访问

public：

公共的

单元测试：

导依赖：

测试和java代码文件夹结构一 一 对应，方便查看。

@Test  注解  进行单元测试

instanceof

”==“和equal（）的区别 ，常量池：

==  ：对于基本数据类型，==判断其真实值是否相等，对于引用数据类型，==判断其地址是否相同。

equal（）：只作用于引用数据类型，用于判断其真实值是否相等

例1：

输出：true

分析：int为基本数据类型   ==比较真实值   输出为true

例二：

输出：

true

true

分析：引用数据类型Integer，==比较地址，equal比较真实值，这里第一个为true的原因是因为java中提供了一个常量池用于存储0~127的Integer

另外，修改c和d的值为128，重新验证c==d   输出false

例三：

输出：false

分析：new 开辟地址空间，就和常量池没关系了，==对引用数据类型比较地址，因此返回false

例四：

输出：

false

true

分析：第一个同例四，第二个比较两个对象的真实值，返回true。

总结：单纯要比较值，基本数据类型用==，引用数据类型全用equal。

static关键字：

被其修饰成为静态变量或静态方法，不需要创建实例来调用。

抽象类：

例：

输出：

接口：

书写规范： 接口名：xxx     该接口的实现类：xxxImpl

接口中的默认方法：

接口中的静态方法：（外界是可以访问的，与私有方法做对比）

接口中的私有方法：（外界无法访问）

内部类：

外部类创建内部类对象：

Inter inter=new Outer（）.new Inter（）；

或者：Outer.Inter inter=new Outer（）.new Inter（）；

package com.example.interClassTest;

public class Outer {
    private int a=0;
    public void m2(){
        System.out.println(a);
        System.out.println(new Outer().new Inter().b);
    }
    public class Inter{
        private int b=1;
        public void m1(){
            System.out.println(a);
            System.out.println(b);
        }
    }

    //内部类可以直接访问外部类的成员（包括私有） 外部类只能通过创建内部类对象来访问内部类成员
    public static void main(String[] args) {
//        Inter inter = new Outer().new Inter();
        Outer.Inter inter=new Outer().new Inter();

        //        System.out.println(inter.b);
        inter.m1();
        Outer outer=new Outer();
//        System.out.println(outer.a);
        outer.m2();

    }
}

通过内部类的内置外部类this来访问外部类的成员变量

package com.example.interClassTest;

public class Outer1 {
    private int a=1;
//java会给内部类存储一个名为this 的外部类实例对象，指向外部类的地址值
    public class Inter1{
        private int a=2;
        private void m1(){
            int a=3;
            System.out.println(a);
            System.out.println(this.a);
            System.out.println(Outer1.this.a);
        }
    }

    public static void main(String[] args) {
        Outer1.Inter1 oi=new Outer1().new Inter1();
        oi.m1();
    }
}

在这里，       this——>Inter1         Outer.this——>Outer1 

静态内部类：

静态内部类只能通过创建外部类对象的方式来访问外部类中的非静态成员和方法

package com.example.interClassTest;
public class Outer2 {
    static int b=1;
    int c=2;
    public static class Inter2{
        int a=0;

        public  void m1(){
            System.out.println(a);
            System.out.println(b);
            System.out.println(new Outer2().c);
            System.out.println("非静态方法，需要创建对象来调用");
        }

        public static void m2(){
            System.out.println("静态方法可以直接调用，不需要创建对象");
        }
    }

    public static void main(String[] args) {
        new Outer2.Inter2().m1();
        Outer2.Inter2.m2();
    }
}

 

局部内部类：

package com.example.interClassTest;
/*
    局部内部类
    存在于外部类的方法中
    可以直接调用外部类的方法和成员变量
    局部内部类（Inter3）所寄生的方法（m）要想使用它的方法或成员变量要先创建对象
 */
public class Outer3 {
    int c=3;
    public void m3(){
        System.out.println("调用外部类的方法");
    }
    public void m(){
        int b=2;
        class Inter3{
            int a=1;
            public void m1(){
                System.out.println(a);
                System.out.println(b);
                System.out.println(c);
                m3();
                System.out.println("局部内部类中的方法被调用");
            }
//            public static void m2(){
//                System.out.println("局部内部类中的静态方法被调用");
//            }

        }
        //创建对象
        Inter3 inter3 = new Inter3();
        inter3.m1();
//        inter3.m2();
    }

    public static void main(String[] args) {
        new Outer3().m();
    }
}

 

匿名内部类：

格式： new 类/接口 {  重写的方法  }； 

其中红色部分为匿名内部类

 整体表示类的子类或者接口的实现类

package com.example.interClassTest;

import com.example.entity.Animal;
import com.example.entity.Swim;
import com.example.interfaceTest.Inter1;

public class Test {
    public static void main(String[] args) {
        /*
            假设狗这个类只需要使用一次
            直接使用匿名内部类的方法让他继承Animal类，重写方法
            就不用专门写一个Dog类了，节省了不必要的工作量
         */
        Animal Dog = new Animal() {

            @Override
            public void eat() {
                System.out.println("狗吃骨头");
            }

            @Override
            public void sleep() {

            }
        };
        Dog.eat();

        //接口的实现类同理
        new Swim(){

            @Override
            public void swim() {
                System.out.println("匿名内部类实现Swim接口，重写swim方法");
            }
        }.swim();   //可以通过new出来的 接口实现类对象 直接调用swim方法
    }
}