Java第三周学习

3.多态:
      前提： 一定是继承，没有继承就没有多态。
      概念： 同一种事物的不同种表现。
    在Java中体现多态的代码有几种？ 3种。
      1. 将一个父类 类型作为一个方法的入参。
      2. 父类类型 变量名 = new 子类类型;
         Father f  = new son();
         instanceof 关键字 用来判断 两个类型是否相同
        if(pet instanceof Dog){   在继承中，需要调用子类独有方法或属性时，才会用instanceof
             Dog dog = (Dog)pet;
             dog.say();
        } 
        向上转型:  Pet pet = new Dog();
         向下转型:  Dog dog = (Dog)pet;     
       3. 接口 变量名 = new 子类类型;
    final关键字：（最终的）
        1.修饰关键字： 必须初始化，不能再改变
            static修饰的final变量被称为静态常量，规范是大写  ------>  public static final int PAGE_SIZE = 60;
            而且能用构造器赋值 ，构造方法不可能加载静态资源。
        2.修饰类： 不能被继承，被称为不可改变类；
        3.修饰方法： 不能被重写。        
4.抽象：

        Java中抽象的体现：
                类是对象的抽象（概念），对象是类的具体实例。
                抽象类是比类还要抽象。
        抽象类： 用abstract关键字修饰，可以修饰类，被称为抽象类，
                可以修饰方法，被成为抽象方法。抽象方法没有方法体。
                public abstract class A{
                    public abstract void eat();
                    public void run(){
                      System.out.println();
                    }
                }
            存在的意义:从代码层次考虑，抽象类就是被继承
                     从设计层面考虑，抽象类是程序的设计思路。
             抽象类的特点：
                1.抽象类有构造器，但是不能自己创建对象。
                2.有属性，有方法，有静态块，有游离块。
有抽象方法的类一定是抽象类，但是抽象类不一定有抽象方法。
        接口： 是比抽象类还要抽象的，是从程序的设计层面考虑问题，是程序设计的思路。
            使用interface关键字，接口只能被实现(implement)
            public interface A{
            
            }
            接口只能继承接口，因为与类之间不是继承关系，所以接口没有构造器，只有抽象方法和静态常量。
===================================================================================
枚举： enum 
Java文件中的类型： class interface enum @Annotation注解
    enum 一般用于自然界中已有的固定的内容。
枚举的特点: 
     不能创建对象， 枚举的首行 必须是 固定名字
     这个 固定名词 一定是，更古不变的;
      即当属性，  又当对象， 构造器赋值
    public enum Season{
        SPRING,SUMMER,AUTOM,WINTER;    
        ………………………………           
        }
        
     组成部分：                       枚举是类，是一种特殊的类    一般与switch联用
     1.属性  第一行 必须是专有名词， 当对象， 属性使用
     2.方法
     3.构造器
     4.静态块儿
     5.游离块儿
     6.专有名词
=================================================================================
类和类之间的关系    (纯理论)
      继承关系
      实现关系
      依赖关系： 从语义级别考虑，具有临时性，偶然性，弱性依赖
                    从代码的级别考虑, 类B作为 类A中方法 的入参,被 类A 使用
      关联，聚合，组合都是将类B作为类A的属性来调用。            
 继承  实现
 依赖 < 关联 < 聚合 < 组合     
===============================================================================
内部类：字面意思： 类的内部还有一个类
       作用：就是为了封装，为了更好的封装。
    |---成员内部类：一个类作为另一个类的成员存在。
                1：Inner类可以获得Outer类的所以资源，无论是私有的还是共有的
                2：Outer类不可以用Inner类的所有资源，无论是私有的还是共有的，    
                            如果想要获取就只能new Inner();创建一个对象来使用。
                3：测试类：Outer.Inner inner = new Outer().new Inner();                            
    |---静态内部类：static
                1.静态内部类 是不可以加载 外部类的 非静态资源的
                    2.外部类想要加载内部类的资源必须 创建内部类的对象
                    3.测试类：  new Outer.Inner(); 外部类.静态内部类    
    |---方法内部类：
                1.方法内部类 依然可以使用外部类的所有资源
                 2.外部类的别的方法是 不能使用方法内部类的资源的，也不能创建对象
                     只能在外部类的方法体中，内部类下面，创建内部类的对象 并调用方法
                3.测试类： 测试类 是永远都不能创建方法内部类的对象的
                           只有调用这个方法的时候 才会 new Inner();
                            而且必须是手动在方法体中  new Inner();
    |---匿名内部类：也成为匿名类，只针对接口或者抽象类
                出现在方法体中:main , 普通方法，不会出现再构造方法中。
                作用:     匿名 类，  作用在不影响 原始功能更的情况下，
                     可以  临时的 修改功能， 拓展功能
=====================================================================================
对象数组：只能存储对象的数组就是对象数组，对象数组中存储的都是对象的引用。
       Object[] obj = new Object[3];
       这个对象数组是万能的容器，什么类型都可以存储
     
     public class Person{
     }
     Person[] p = new Person[数组长度];
     public String toString(){
             //toString方法输出对象的属性的值。
             return 字符串;
     }
=====================================================================
单例设计模式：
      当我们的程序中只需要一个对象的时候，就会用到单例设计模式;
      java中的 单例设计模式有几种? 
   1.饿汉模式        时刻准备好一个已经new 好的对象。
   public class Person {
    private static Person p = new Person();
    private Person(){    
    }
    //普通方法
    public static Person getPerson(){
        return p; 
    }
}
   2.懒汉模式    只有在调用这个方法的时候才会new一个实例对象。
   public class Student {
    private static Student student = null;
    private Student(){
    }
    public static Student getStudent(){
        if(student == null){
            student = new Student();
        }
        return student;
    }
}
  
 特点 :  
    1.私有的构造器     外界 不能创建对象
      2.公共的 静态方法
      3.静态成员属性
============================================================
工具类    
    Scanner sc  = new Scanner(System.in);
    nextInt(); 控制台输入什么返回什么。
    Random r = new Random();
    nextInt(int bound);     工具类随机给出。