note_doit_day10

1.代码块:
    1.局部代码块:用来限制变量的作用域范围
    2.构造代码块(成员代码块)
        当创建对象时 成员代码块会执行 创建一次 执行一次 优先于构造方法
    3.静态代码块
        当类加载时 静态代码块会执行 类只加载一次 所以静态代码块只执行一次
        创建类的对象时
        访问静态的成员变量
        访问静态的方法
        创建子类对象
    
    tips:静态代码块>构造代码块>构造方法
    EXP:
        static {
        System.out.println("静态代码块");
        }

        //成员代码块 构造代码块
        {
            System.out.println("成员代码块");
        }

        public Person(){
            System.out.println("构造方法");
        }

        public static void method(){
            System.out.println("静态成员方法");
        }

2.权限:
     public     公共权限:可以修饰,类,方法,成员变量,任意包下都可以访问
     default     默认什么都不写,包权限,可以修饰,类,方法,成员变量,只能在当前包下访问
     protected     受保护的权限,可以修饰,方法,成员变量,当前包和其他包下的子类可以访问
     private     私有的权限,可以修饰,方法,成员变量,本类中可以访问

     abstract     抽象的,可以修饰,类,方法
     final      最终的修饰符,可以修饰,类,方法,变量
     static     静态修饰符,可以修饰,方法,成员变量

    tips:
    1.private只能在本类中访问,子类看不到,不能重写,而abstract要求子类必须重写
    2.final修饰的类,子类不能继承,而abstract修饰的类,要求子类必须继承
    3.static 和abstract都可以修饰方法,但是static修饰的方法,类名可以直接访问,而abstract修饰的方法没有方法体
    在同包下的无关类中 private不能访问
    同包下的子类  private不能访问
    EXP:(4个权限可以互相访问)
        public class Person {

        public void method1(){
            System.out.println("public");
        }

         void method2(){
            System.out.println("默认权限 default");
        }

        protected void method3(){
            System.out.println("protected");
        }

        private void method4(){
            System.out.println("private");
        }

        public void funtion(){
            method1();
            method2();
            method3();
            method4();
        }
    }
    
3.匿名内部类:
    定义:属于局部内部类的一种
    作用:临时创建一个类的子类对象的快捷方式

    格式:
        new 父类/接口(){
            重写方法
        };
    
        1.定义了这个类子类
        2.同时创建了这个子类的对象
    需要Fly接口的实现类对象
        1.定义实现类实现Fly接口
        2.重写抽象方法
        3.创建实现类对象 调用方法
    EXP:
        public class Bird implements Fly {
        @Override
        public void open() {
            System.out.println("张开小翅膀 我要上天了");
        }

        @Override
        public void fly() {
            System.out.println("我已经上天了");
        }

        @Override
        public void close() {
            System.out.println("掉下来了");
        }
    }
    
        public interface Fly {
        public abstract  void  open();
        public abstract  void fly();
        public abstract  void close();
    }
    Test:
        public class Test {
        public static void main(String[] args) {

            Fly f = new Bird();
            f.open();
            f.fly();
            f.close();

            new Bird().fly();

            System.out.println("--------------------------");

            Fly fj = new Fly(){

                @Override
                public void open() {
                    System.out.println("open");
                }

                @Override
                public void fly() {
                    System.out.println("fly");
                }

                @Override
                public void close() {
                    System.out.println("close");
                }
            };
            fj.open();
            fj.fly();
            fj.close();
            new Fly(){

                @Override
                public void open() {
                    System.out.println("open");
                }

                @Override
                public void fly() {
                    System.out.println("fly");
                }

                @Override
                public void close() {
                    System.out.println("close");
                }
            }.fly();
        }
        public static void method(Fly f){

        }
    }
    引用类型作为方法的参数和返回值:
        public class Test {
        public static void main(String[] args) {

            Person p = new Person();
            //传入当前类对象
            method(p);
            method(new Person());

            //传入当前类的子类对象 因为多态
            Student s = new Student();
            method(s);
            Person p2 = new Student();
            method(p2);
            method(new Student());
            Person p3 =  method2();//null   new Person();  new Student();
        }

        //具体类作为方法的参数,可以传入当前类的对象,也可以传入当前类的子类对象
        public static void method(Person p ){
        }
        //具体类作为方法的返回值类型
        public static Person method2(){
            //可以返回Person对象
            //return new Person();
            //可以返回Person的子类对象
            return new Student();
            //可以返回null
            //return null;

        }
    }

4.经理员工案例:
    公司类:
        public class GongSi {
        private double zongZiChan;
        private ArrayList<YuanGong> list;

        public GongSi() {
        }

        public GongSi(double zongZiChan,ArrayList<YuanGong> list){
            this.zongZiChan = zongZiChan;
            this.list = list;
        }

        //定义一个方法 可以查看公司信息
        public void show(){
            System.out.println("总资产"+zongZiChan);

            for(int i = 0 ;i<list.size();i++){
                YuanGong yg =  list.get(i);
                System.out.println("姓名:"+yg.getName());
                System.out.println("工号:"+yg.getId());
                System.out.println("存款:"+yg.getCunKuan());
                System.out.println("工资:"+yg.getGongZi());
                //如果员工要是经理 需要打印奖金
                if(yg instanceof  JingLi){

                    //向下转型
                    JingLi jl = (JingLi)yg;
                    System.out.println("奖金:"+jl.getJiangJin());
                }

                System.out.println("------------------------------");
            }
        }
        public void  faGongZi(){
            //遍历集合 依次获取到每个员工
            for(int i = 0 ;i<list.size();i++){
                YuanGong yg= list.get(i);
                // 公司的总资产减少
                //减去每个员工的工资
                zongZiChan -= yg.getGongZi();

               // 员工的存款增加
                //原来的存款+ 工资
                yg.setCunKuan( yg.getCunKuan() + yg.getGongZi());

                // 如果这个员工是经理还要减去奖金
                if(yg instanceof  JingLi){
                    JingLi jl = (JingLi)yg;
                    zongZiChan -= jl.getJiangJin();

                    // 如果员工是经理 还要加上奖金
                    //原来的存储+奖金
                    jl.setCunKuan(jl.getCunKuan() + jl.getJiangJin());
                }
            }
        }
        //定义一个给员工调整薪资的方法
        public void  updateGongZi(YuanGong yg,double money)
        {
            //设置员工的工资为 原来的工资 + 调整的薪资
            yg.setGongZi(yg.getGongZi() + money);
        }

        //定义一个抽取幸运员工的方法
        public YuanGong getLucky(){
            //在集合的索引范围内生成一个随机索引
            Random r = new Random();
            int index = r.nextInt(list.size());

            return list.get(index);
        }
        //接口作为方法的参数 只能传入其实现类对象
        public void  party(Service s){
            System.out.println("开会");
            s.service();
        }

        public void setList(ArrayList<YuanGong> list){
            this.list = list;
        }
        public ArrayList<YuanGong> getList(){
            return list;
        }

        public double getZongZiChan() {
            return zongZiChan;
        }

        public void setZongZiChan(double zongZiChan) {
            this.zongZiChan = zongZiChan;
        }
    }
    员工类:
        public class YuanGong {
        private String name;
        private String id;
        private double cunKuan;
        private double gongZi;

        public YuanGong() {
        }

        public YuanGong(String name, String id, double cunKuan, double gongZi) {
            this.name = name;
            this.id = id;
            this.cunKuan = cunKuan;
            this.gongZi = gongZi;
        }

        public String getName() {
            return name;
        }

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

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public double getCunKuan() {
            return cunKuan;
        }

        public void setCunKuan(double cunKuan) {
            this.cunKuan = cunKuan;
        }

        public double getGongZi() {
            return gongZi;
        }

        public void setGongZi(double gongZi) {
            this.gongZi = gongZi;
        }
    }
    经理类(继承员工):
        public class JingLi extends YuanGong {

        private double jiangJin;

        public JingLi(){

        }

        public JingLi(String name, String id, double cunKuan, double gongZi,double jiangJin){
            super(name,id,cunKuan,gongZi);
            this.jiangJin = jiangJin;
        }

        public double getJiangJin() {
            return jiangJin;
        }

        public void setJiangJin(double jiangJin) {
            this.jiangJin = jiangJin;
        }
    }

5.Object类:
    java.lang.Object 所有类的超类 每个类都直接或者间接继承自Object
    方法
    String  toString()  将对象转换为字符串    对象的数据类型 + @ + 地址值(哈希值)
        在Object类中 或者 子类不重写 打印的是地址值
        而一般情况 子类都会对这个方法进行重写 返回 属性内容
    EXP:
        public class Demo01_Object {
        public static void main(String[] args) {
            Object obj = new Object();
            String s = obj.toString();
            System.out.println(s);
            System.out.println(obj);

            Person p = new Person("柳岩",38);
            //当打印对象名时 会默认调用其toString方法
            System.out.println(p);
            System.out.println(p.toString());

            //由于字符串 重写了toString方法 所以 打印字符串的变量名时 打印的是字符串的内容
            
            String str = "abc";
            System.out.println(str);
            System.out.println(str.toString());

            /*
                 ArrayList重写了toString方法  打印的是内容 并不是地址值
             */
            ArrayList<Integer> list=new ArrayList<>();

            list.add(10);
            list.add(20);

            System.out.println(list);
            System.out.println(list.toString());
        }
    }

6.API的使用:
    应用程序接口.(JDK API 1.6版本的API有官方中文版)
    1.索引:直接搜索关键词
        实现了哪些接口,继承了哪个类,从哪个版本开始...