day04-面向对象【内部类、static、包、访问修饰符、final】

1.接口

是一个比抽象类还抽像的类，使用interface关键词定义。
里面只能定义抽象方法和常量；
不能new ，不能创建对象；

使用：
    1.定义接口的实现类：
        修饰符 calss 类名 implements 接口名{
            实现接口中所有的方法；
            }
    2.创建实现类的对象；
    3.通过实现类对象调用实现类方法；

2.多态

父类类型的变量只想子类的对象；

格式：
    父类名 对象名 =new 子类名（参数列表）；

    在重写变量过着方法的情况：
        1.如果重写了方法，通过多态访问时，访问子类中的方法；
        2.如果重写了变量，通过多态访问变量时，访问父类的变量；

3.static 关键字

静态的意思；
使用修饰这个类的，所有对象的共享数据的，它属于类，不属于某一个对象，只有一个对象修改了这个数据，就会影响到其他对象的使用；

访问方式：
    1.通过对象名来访问：
        格式：对象名.静态成员；
    2.静态的访问方式：
        格式： 类名.静态成员；

    推荐使用第二种访问方式；

4.静态代码块

格式：
    static{
        静态代码；
    }
静态代码块会在以任何方式第一次使用这个类时，被执行，而且是最先被执行，而且只执行一次。

特点：
    1.优先于构造方法被执行；
    2.只能被执行一次；
    3.静态代码块优先于静态方法被执行；
应用场景：
    通常用于初始化静态变量，保证这些变量只能被赋值一次；

5.final 关键字

是最终的。不可修改的；
final 可以修饰类，方法，变量；
1.final修饰类：
    格式：修饰符 final class 类名{。。。}；
    特点：被final修饰的类是不能被继承的。
2.final修饰变量:
    格式：修饰符 final 返回值类型 方法名（参数列表）{
                方法体；
                renturn 返回值；
            }
    特点：被final修饰的方法是不能被重写的；
3.final修饰变量：
    格式： 修饰符 final 数据类型 变量名=初始值；
    特点： 被final修饰的变量的值不能被改变，其实就是常量；

6.包

是用来存储class文件的文件夹，可以使用这些文件夹管理你的程序文件；
在项目中如何分包：
    先创建一个最顶层的包：
        公司域名的反写.项目英文名称的缩写；
        例如： cn.itcast.oa;
1.按照功能模块的名称分包:


        按照功能模块名称创建不同的包:
            cn.itcast.oa.user
            cn.itcast.oa.email
            cn.itcast.oa.permission
            ...
2.按照程序文件的类型分包:

        cn.itcast.oa.web
        cn.itcast.oa.service
        cn.itcast.oa.service.impl
        cn.itcast.oa.dao
        cn.itcast.oa.dao.impl
        cn.itcast.oa.utils
        ... 


推荐使用第二种方式分包;

导包:

    关键字import.
    当使用到的类与当前类不在同一个包下,而且不在java.lang.

7.访问权限修饰符

用来限制类，方法，变量的访问范围的。

public（公共的，共用的）-protected（受保护的）-default（默认的）-private（私有的）
从左到右权限依次变小；

1.被public修饰的类，方法，变量，在任何类中都可以访问；
2.被private修饰的变量和方法只能在本类中访问；

8.内部类

如果B类是定义在A类的里面，就把B类叫做内部类；

分类：
    成员内部类；
    局部内部类；
class A{

    public String name;

    // 写在了成员的位置
    // 成员内部类
    class B{
        B类自己的代码;
    }

    public void method01(){
        ....
    }

    public void method02(){
        ....
        int a = 100;
        int b = 200;
        // 局部内部类
        class C{
            C类自己的代码;
        }
    }
}

9.成员内部类

格式：
    class 外部类{
        成员变量；

        //写在了成员的位置
        //成团内部类；
        class 内部类{
            内部类自己的代码；
        }
        成员方法；
    }

使用内部类的格式：
    外部类.内部类  内部类对象=new 外部类（）.new 内部类（）；
    内部类对象.内部类的成员；

    在外部类中是把内部类作为一个成员来使用的。

    例如：
        Outer.Inner inner=new Outer().new Inner();

10.局部内部类

格式：
    class 外部类{
        成员变量；
        public void method（）{
            内部类自己的代码；
            }
        }
    }
由于局部内部类是定义在方法里面的，所以它的使用范围仅限于这个方法内部；

11.匿名 内部类对象

创建了一个内部类的对象，没又给它取名字，那么这个对象就叫匿名内部类对象；

格式：
    public class Fu{
        ....
    }
    public class test{
        ...
        public void method（）{
            //通过父类的构造方法创建子类对象，然后赋值给父类类型的变量：多态；
            Fu f=new Fu（）{
                //重写父类中的方法
            }；
        }
    }

示例代码：
package pack15_innerclassobject;

public class InnerObjectDemo {

public static void main(String[] args) {

    // 多态
     Fu f = new Zi();
     f.method01();

// 匿名内部类对象
// 匿名内部类对象调用结束后,会被垃圾回收期立即回收,释放它占用的内存空间
            // 这样可以节省内存空间
    new Fu(){
    // 重写父类中的方法method01
    @Override
    public void method01() {
    System.out.println("--Zi-----method01------------");
            }
        }.method01();

    // 创建一个匿名内内部类对象,然后给它取个名字叫f2
        Fu f2 =new Fu(){
        // 重写父类中的方法method01
            @Override
            public void method01() {
    System.out.println("--Zi-----method01------------");
            }
    };

    f2.method01();
    System.out.println(f2.a);

    // 相当于下面的一行代码;
    // new Zi().method01();

System.out.println("====程序还没有结束===========");
        }
}

匿名内部类对象的使用场景：
    在整个项目中只有一个地方使用这个对象时，才把这个对象定义为匿名内部类对象。

12.练习题
1.类名座位方法参数类型或者返回值类型

    /*
     * 定义方法时,如果参数的类型为类名类型的;
     * 当调用方法时,需要给方法传递这个类的对象;
     */
    public static void  setPerson(Person p){
        p.age = 30;
        p.name="冬冬";

        System.out.println(p.age);
        System.out.println(p.name);
    }

    /*
     * 定义方法时,如果方法的返回值类型为类名类型的;
     * 当给这方法返回数据时,必须返回这个类的对象;
     */
    public static Person getPerson(){
        Person p = new Person();
        p.age = 25;
        p.name="蓉蓉";
        return p;
    }


2.抽象类类名作为方法参数类型或者返回值类型

3.接口名作为方法参数类型或者返回值类型

    USB usb = new Mouse();
    public void useUSB(USB usb){
        usb.open();
    }

    public USB getUSB(){
        // USB usb = new  Mouse();
        Mouse m = new Mouse();
        return m;
    }