java入门了解03

ASSCII表

.

1.final关键字
    （1）含义：最终的意思，修饰方法，类，变量
    （2）特点：
          A：修饰类，不能被继承
          B：修饰的方法，不能被重载
          C：修饰的变量，是产量
    （3）面试相关
          A：用在局部变量时
               a：基本类型 值不能改变
               b：引用类型 地址值不能改变 但是内容可以变
          B：对象初始化时机
               a：只能初始化一次
               b：常见的给值
                   定义的时候（推荐）
                   构造方法中
2.多态
    （1）含义：同一对象在不同时刻体现的不同状态
    （2）前提：
           A：有继承或实现的关系
           B：有方法的重写，这样多态才有意义
           C：父类或父类引用指向子类对象

      多态的分类：
           a.具体类多态
              class Fu{}
              class Zi extends Fu{}

              Fu f=new Zi();
           b.抽象类多态
              abstract class Fu{}
              abstract class Zi extends Fu{}

              Fu f=new Zi();
           c.接口类多态
             interface Fu{}
             class Zi implements Fu{}

             Fu f=new Zi();

    （3）多态中成员访问特点
           A：成员变量
               编译看左边，运行看左边
          B：成员方法
              编译看左边，运行看右边
          C：构造方法
             子类的构造方法默认访问父类构造函数
          D：静态方法
            编译看左边，运行看左边

          为什么？
            因为成员方法有重写
    （4）多态的好处
          A：提高代码的维护性（继承）
          B：提高代码的扩展性（接口实现体现）
    （5）多态的弊端
          父类不能访问子类的方法

     现象：
         子可以看做父类，父类不能看做子类
3.抽象类
    （1）含义：把多个对象共性的东西提取到一个类中这是继承，但是有的时候我们需要的是方法声明一样
                    但是具体的方法实现不一样，所以我们再给出这些共性的方法时就不能给出具体的方法体，
                    而一个没有具体方法实现的方法是抽象方法，而一个类中要是有方法为抽象方法这个类就是抽象类
    （2）特点：
           A：必须用关键字abstract
           B：抽象类中可有抽象方法也可以有非抽象方法
           C：抽象类不能实例化
           D：抽象类的子类
                 a.是一个抽象类
                 b.是一个具体类。这个具体类必须实现抽象类中的所有抽象方法
    （3）抽象类中的成员特点：
           A：成员变量
               有变量有常量
           B：成员方法
              有构造方法
           C：成员方法
              必须有抽象方法，可以有非抽象方法
    （4）抽象类中的几个小问题
           A：抽象类有构造方法，不能实例化，那么构造方法有什么用？
               子类继承了抽象类，就可以调用父类的构造方法，就是给子类用的
           B：一个类没有抽象方法，却定义为抽象类，有什么用？
                避免其实例化的
           C：abstract不能喝哪些关键字共存
              a：final 冲突
              b：private 冲突
              c：static 无意义
4.接口
    （1）提供给具体类一个扩展功能时考虑到用接口
          案例：猫狗案例
                 分析：从具体到抽象
                         猫：吃饭，睡觉
                         狗：吃饭，睡觉

                         由于共性功能，所以，我们抽象出一个父类
                         动物：吃饭，睡觉

                         猫继承动物
                         狗继承动物

                         跳高是一个额外扩展功能，此刻就应想到用接口给特定对象扩展跳高的扩展功能
                         接口：
                         跳高
                         部门猫：实现跳高
                         部分狗：实现跳高
                         实现：从抽象到具体
                         //定义跳高接口
                         interface Jumpping{
                         //跳高功能
                         public abstract void jump();
                         }
                         //定义一个抽象类
                         abstract class Animal{
                         public Animal(){}
                         public abstract void eat();
                         }
                         //具体猫狗 有跳高能力的猫需要实现接口
                         class Cat exends Animal implements Jummping{
                         //实现抽象方法
                         //实现接口的特定功能方法
                          }
                         这种分析的模式：
                                 分析：从具体到抽象；实现：从抽象到具体
    （2）特点：
             A：interface关键字
             B：接口不能实例化
             C：类实现接口implements
             D：接口的实现
                   a.是一个抽象类
                   b.是一个具体类，必须重写接口中的所有的抽象方法
    （3）接口的成员特点：
             A：成员变量：
                 只能是常量；默认修饰public abstract final
             B：成员方法：
                 只能是抽象的，默认修饰public abstract
             C：构造方法：没有构造方法
    （4）抽象类与接口区别
             A：成员区别：
                  抽象类中有常量也可有变量，接口只能有常量
                  抽象类可以有非抽象方法，接口只能有抽象方法不能有非的
                  抽象类有构造方法，接口没有
             B：关系区别:

             C：设计理论区别
                   a.抽象类：is a;考虑到共性
                   b.接口：like a;考虑到扩展功能

5.链式编程
     对象.方法1().方法2().方法3()
     这种用法：其实在方法1()调用完后应该有一个对象
6.包
    （1）其实就是一个文件夹
    （2）作用就是对类进行分类管理
    （3）注意事项：
           A：package语句必须在文件中的第一天有效语句
           B：在一个java文件中，只能有一个包
           C：如果没有package，默认就是无名包
    （4）带包的编译和运行
              多了个 -d .
              cmd>javac -d . HelloWorld.java
              其中：-d:directory,指定目录
                      . :当前目录
              需要加包名
              cmd>java 包名名称.HelloWorld
7.导包
       import 包名...类名（推荐）
       import 包名...*（不推荐）
       package>import>class
8.权限修饰符
       public private protect interal了解他们这件的区别
9.内部类（理解）
    可以参考博客“Java内部类种类及使用解析”
    （1）静态类部类（static）
           只能访问外部类的静态成员
    （2）成员内部类（无static）
           类似一个实例变量
           可以访问外部类的所有成员方法
    （3）局部内部类
           用在方法中；像局部变量一样，不能被public protected private static 修饰
           只能访问方法中定义的final类型变量
    （4）匿名内部类(重要)
           用的地方比较多
           匿名内部类就是没有名字的局部内部类例如
           在方法中出现new Data(){}
           一般匿名内部类都会继承父类或者实现接口，也可以重写父类方法
    （5）匿名内部类的面试题

　　　　当需要一个对象，而该对象所属的类需要实现一个接口或继承一个类，并且该对象只是用一次，用匿名内部类
                interface Inter{
                   void show():
                }
                class Outer{
                //补全代码
                /*
                答案：（尽量自己写）匿名类一般都会继承父类或者实现接口这里就是实现了接口

                

 public static Inter method(){
                return new Inter(){
                public void show(){
                System.out.print("HelloWorld");

                }
            }
            }
          */
          }
            class OuterDemo{
            public static void main(String[] args){
            Outer.method().show();//"要求输出HelloWorld"
                }
            }