note_doit_day09

1.final修饰符:
    1.final最终修饰符  final可以修饰 类 方法和变量(成员变量 局部变量)
        final修饰类  不能被继承
        final修饰方法 不能被重写
        final修饰变量 只能赋值一次 不可以二次赋值 是常量
    2.final修饰符 修饰引用数据类型变量 地址值不能改变 但是属性值可以改变
    3.final修饰成员变量 不能使用默认值 必须在创建对象之前赋值
        1.以显示赋值
        2.以在构造方法中赋值 但是每个构造方法都赋值
    
    EXP1:
        public class Demo01_Final {

        public static void main(String[] args) {
            //  final修饰符 修饰引用数据类型变量 地址值不能改变 但是属性值可以改变
           final Person p = new Person();
            p = new Person();
            p.name = "柳岩";
            p.name = "唐嫣";
            //对于p2这个对象来说 age的值永远都是3
            Person p2 = new Person();
            System.out.println(p2.age);

            Person p3 = new Person("aaa");
            //p3.age = 100;
            System.out.println(p3.age);
        }
    }
    EXP2:
    //final修饰的类不能被继承
    public /*final*/ class Fu {
        //final修饰的方法不能被重写
        public /*final*/ void  method(){

        //final修饰变量 只能赋值一次 是常量
       final int a = 10;
      final  int b ;
      b = 20;
        }
    }

2.接口:
    接口的使用
        类实现接口
        1.接口不能创建对象
        2.需要定义实现类实现接口
        3.重写所有抽象方法
        4.创建实现类对象 调用方法
    接口的成员特点
        1.接口没有构造方法
        2.接口中的成员变量 不再是变量 都是常量
        3.被默认修饰符修饰  public static final
        4.常量的命名规则  每个字母都大写 多个单词用_连接
        5.接口中的成员方法 默认修饰符 public abstract修饰
    接口的特点
        1 类实现接口 可以单实现 也可以多实现
          类可以在继承一个类的同时 实现多个接口
        2.接口与接口之间是继承关系 可以单继承 也可以多继承
        
    接口的默认方法
        public default 返回值类型 方法名(){
        }
     实现类可以直接使用这个方法 也可以对默认方法进行重写

    接口的静态方法
     public static 返回值类型 方法名(){
     }
     实现类不能使用,由接口名直接调用  接口名.方法名(实际参数);
     
    Test:
        public class Test {
    }
    interface  A{
        public abstract void show1();
        public abstract  void show();

        public abstract void show4();
    }
    interface B{
        public abstract void show2();
        public abstract  void show();
    }
    abstract  class Fu{
        public abstract void show3();

        //由于父类中已经定义类show4方法  子类虽然没有重写接口A的show4的方法
        //但是继承了Fu类的show4相当于 重写 不报错 子类也可以自己再重写show4方法
        public void show4(){

        }
    }
    class C extends Fu implements A,B{

        //重写接口A的show1方法
        @Override
        public void show1() {

        }

        //重写接口B的show2()方法
        @Override
        public void show2() {

        }
        //重写接口 A和B 相同的show方法
        //如果接口中有相同的方法 重写一次即可
        @Override
        public void show() {
        }
        //重写父类方法
        @Override
        public void show3() {

        }
    }
    
3.多态:
    public class Test {
        public static void main(String[] args) {
            //具体类多态  具体父类 变量名 = new 子类对象();
            Person p = new Student();
            p.eat();

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

            //抽象类多态 抽象父类 变量名 = new 子类对象();
            Animal a = new Cat();
            a.sleep();

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

            //接口多态  接口 变量名 = new 实现类对象();
            Fly f = new Bird();
            f.fly();

        }
    }
    
    1.多态后访问成员的特点
        1.成员变量
             编译时 需要先到父类中去找 有没有这个变量 如果有编译通过
             如果没有 编译报错
             运行时 打印的是父类成员变量的值

            编译时  看左边
            运行时  看左边
        2.成员方法
            编译时 需要先到父类中去找 有没有这个方法 如果有编译通过
            如果没有 编译报错
            运行时  运行的是子类重写后的方法

            编译时 看左边
            运行时 看右边
    多态后 一切表现都是父类的表现 只有方法运行的是重写后的方法
    EXP:
        public class Test {
        public static void main(String[] args) {
            //多态创建对象
            Fu fz = new Zi();
            System.out.println(fz.name);
            //父类中没有这个变量 不能访问
    //        System.out.println(fz.age);

            fz.method();
            //多态后只能调用父类的功能 不能调用子类特有的功能 运行的是子类重写后的方法
    //        fz.method2();
        }
    }
    2.转型:
        1.向上转型(自动类型提升)
            int a = 10;
            double b = a;
        2.向下转型(强制类型转换)
            int a = (int)10.1;
            Zi zi = (Zi)fz;
    3.多态的利弊:
        好处:提高了程序的扩展性
        弊端:多态后不能访问子类特有的功能 要想访问 要么重新创建子类对象 要么向下转型

4.static静态修饰符:
         *:static 静态修饰符 可以修饰类的成员  成员变量 成员方法
           被static修饰的成员 不再单属于某个对象 属于类 被所有对象所共享
    1.静态内容的访问
          对象.变量名;          //不推荐
          对象.方法名(实际参数); //不推荐
          类名.变量名;
          类名.方法名(实际参数);
    2.静态的注意事项
         静态的内容优先于对象出现 所以静态只能直接访问静态
         不能访问非静态 静态方法中不可以使用this/super
    Demo:
        public class Demo01_Static {
        public static void main(String[] args) {
            Person p = new Person();
            p.name = "柳岩";

            p.age = 100;

            Person p2 = new Person();
            p2.name = "啊啊啊";

            System.out.println(p2.age);

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

            //静态成员变量的访问
            System.out.println(Person.age);

            Person.method();

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

            Demo01_Static ds = new Demo01_Static();
            ds.method();

        }
        public  void method(){

        }
    }