JAVAday9-10笔记

• 多态
  
  • 前提
    
    1. 要有继承方法
    2. 要有方法重写
    3. 要有父类引用指向子类对象
  • 成员对象
    
    • 编译看左边，运行看左边
  • 成员方法
    
    • 编译看左边，运行看右边
  • 静态方法
    
    • 编译看左边，运行看左边
  • 向上转型和向下转型
    
    • 父类引用指向子类对象（向上转型）
      
      • Person p = new Student();
    • 向下转型
      
      • Student s = （Student）p;
  • 好处
    
    • 提高维护性
    • 提高扩展性
  • 弊端
    
    • 不能使用子类的特有属性和行为
• 抽象类
  
  • abstract
    
    • abstract class 类名
    • public abstract void xxx();
  • 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
  • 抽象类不能被实例化，由具体的子类实例化。
  • 子类
    
    • 要么是抽象类
    • 要么重写抽象类中的所有抽象方法
  • 强制子类重写抽象方法
  • abstract不能和private（私有子类不能访问）/static（静态可以通过类名.调用）/final（final不能被重写）共存
• 接口
  
  • interface
    
    • interface 接口名{}
  • 类实现接口用implements表示
    
    • class 类名 implements 接口名{}
  • 接口不能被实例化 用多态的方法实例化
  • 子类
    
    • 可以是抽象类 但无意义
    • 可以是具体类，重写所有抽象方法
  • 成员特点
    
    • 成员变量
      * 常量，静态并公共的
      * public static final
    • 构造方法： 没有构造方法
    • 成员方法： 只能是抽象方法
      
      • public abstract
• 类与类： 继承： 只能单继承，可以多层继承
• 类与接口： 实现： 可以单实现，也可以多实现
  
  • 可以在继承一个类的同时实现多个接口
• 接口与接口： 继承： 可以单继承，也可以多继承
• 抽象类和接口的区别
  
  • 抽象类：
    
    • 成员变量： 可以变量，也可以常量
    • 构造方法： 有
    • 成员方法： 可以抽象，也可以非抽象
  • 接口
    
    • 成员变量： 只可以常量
    • 成员方法： 只可以抽象
  • 抽象类 被继承体现的是“is a”，抽象类定义的是该继承体系中的共性功能
  • 接口 被实现体现的是“like a”，接口定义的是该继承体系的扩展功能。
• 包： package
  
  • 作用 对字节码（.class）进行分类存放
  • 实质就是文件夹
  • 格式： package 包名; 多级包用.分开
  • 注意：package语句必须是程序的第一条可执行的代码
    package语句在一个java文件中只能有一个
    如果没有package，默认表示无包名
• 带包的类编译和运行
  
  • javac编译的时候带上-d即可 javac -d . HelloWorld.java （DOS）
  • 通过java命令执行 java 包名.HellWord
• import
  
  • import 包名;
  • 这种方式导入是到类的名称。
  • 虽然可以最后写*（表示从包内一一匹配），但是不建议。
    链式编程：每次调用方法后还能继续调用方法，证明调用方法返回的是一个对象
• 四种权限修饰符

•             本类   同一个包下(子类和无关类)  不同包下(子类)    不同包下(无关类)
  private     Y       
  默认          Y       Y
  protected   Y       Y                           Y
  public      Y       Y                           Y               Y
  

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

  • 修饰符：
    
    • 权限修饰符：private，默认的，protected，public
    • 状态修饰符：static，final
    • 抽象修饰符：abstract

  • 类：

    • 权限修饰符：默认修饰符，public
    • 状态修饰符：final

    • 抽象修饰符：abstract

    • 用的最多的就是：public

  • 成员变量：

    • 权限修饰符：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
• 内部类概述和访问特点
  
  • 内部类访问特点
    
    • 内部类可以直接访问外部类的成员，包括私有。
    • 外部类要访问内部类的成员，必须创建对象。
    • 外部类名.内部类名 对象名 = 外部类对象.内部类对象;

class Outer {
            public int num = 10;
            class Inner {
                public int num = 20;
                public void show() {
                    int num = 30;
                    System.out.println(?);
                    System.out.println(??);
                    System.out.println(???);
                }
            }
        }
        class InnerClassTest {
            public static void main(String[] args) {
                Outer.Inner oi = new Outer().new Inner();
                oi.show();
            }   
        }
//要求：使用已知的变量，在控制台输出30，20，10。
//? = num;
//?? = this.num;
//??? = Outer.this.num;

• 局部内部类访问局部变量必须用final修饰
  
  • 因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
  • 但是jdk1.8取消了这个事情,所以我认为这是个bug
• 匿名内部类
  
  • 是一个继承了该类或者实现了该接口的子类匿名对象。
  • 就是内部类的简化写法。
• 前提：存在一个类或者接口
  
  • 这里的类可以是具体类也可以是抽象类。
• 格式：
  
  • 
    new 类名或者接口名(){
    重写方法;
    }

        abstract class Person {
            public abstract void show();
        }

        class PersonDemo {
            public void method(Person p) {
                p.show();
            }
        }

        class PersonTest {
            public static void main(String[] args) {
                //如何调用PersonDemo中的method方法呢?
                PersonDemo pd = new PersonDemo ();
                pd.method(new Person(){
                    public void show(){
                        System.out.println();
                    }
                });
            }
        }

interface Inter { void show(); }
        class Outer { //补齐代码 }
        class OuterDemo {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }
        要求在控制台输出”HelloWorld”


public class Test_NoNameInnerClass {
    public static void main(String[] args) {
        Outer.method().show();
    }
}
interface Inter {
    void show();
}
class Outer { //补齐代码 }
    public static Inter method(){
        return new Inter() {
            public void show() {
                System.out.println("HelloWorld");
            }
        };
    }
}