java se step 4

abstract: 多态、接口、参数与返回值、内部类、正则表达式

 

多态

        前提：
               1)必须有继承关系；
               2)必须有方法重写；
               3)必须有父类引用指向子类对象(向上转型)
                      格式:   父类名 对象名 = new 子类名();

 

        成员访问特点:
                1)成员变量的访问特点:  编译看左,运行看左 (左:父类   右:子类)
                2)成员方法(非静态)的访问特点: 编译看左,运行看右                
                3)构造方法:作用:就是给对象进行初始化的
                4)静态的成员方法的访问特点:   编译看左,运行看左

 

        好处:
                 1)提高代码的扩展性
                 2)提高代码的维护性

 

         弊端:
                 不能访问子类特有功能；
                  解决方案：向下转型

 

          抽象类多态:
                 抽象类中的抽象方法必须重写；

 

 

 

 

接口interface

          格式:
                  interface 接口名{
                   }
                  class 类名 implements 借口名{
                   }

 

           特点:
                     1) 接口不能实例化；
                     2) 接口的子实现类要实例化，否则没意义
                     3) 接口的实现类是具体类: 接口名 对象名 = new 子实现类名();
                     4) 接口的方法都是抽象方法
                     5) 成员变量默认修饰符：public static final
                         成员方法默认修饰符：public abstract

           类和接口的关系: implements 实现关系，而且一个类继承另一个类的同时还能实现多个接口
           类和类的关系: extends 继承关系,单继承，不能多继承，可多层继承:
           接口与接口的关系: extends 继承关系,可单/多继承:

 

 

 

 

args_and_return          

            形式参数问题:
                  前面讲过基本数据类型,现在讲引用数据类型为具体类,抽象类,接口时的形参问题
                  具体类需要该具体类对象,抽象类需要抽象类子类对象,接口类需要子实现类对象
           方法返回值：
                   基本类型是返回什么基本类型数据就用什么基本类型接收
                   引用类型是具体类时需要返回该具体类,具体对象
                   引用类型是抽象类时返回的是该抽象类的子类对象;

                  关于链式编程：每次调用的都是返回的对象,只有对象才能调用方法;

 

 

 

 

 

内部类

                  局部内部类(在方法中定义的类):
                          1) 局部内部类里的成员方法直接可以访问外部类的成员,包括私有

                          2) 但局部内部类访问局部变量则该变量必须被final修饰                                                

                          3) 访问特点:
                                   在外部类的成员方法中创建内部类对象,即对象名.局部内部类的成员方法

 

 

                  成员内部类(在外部类的成员位置):
                          1) 一般通过 外部类名.内部类名 对象名 = 外部类对象.内部类对象 来创建对象调用内部类的方法;

                                                   Outer.Inner oi = new Outer().new Inner();

                          2) 当成员内部类被static修饰时,是为了方便调用   外部类名.内部类名.方法
                              当成员内部类被private修饰时,是为了保证数据安全性

 

 

                   匿名内部类(接口中使用最频繁):
                          特点:
                                    节省内存空间,使用方便

                          格式:
                                    new 类名/接口名(){
                                        重写/实现一些方法()
                                      }

                          本质:
                                   是一个继承了某一个类或者实现了某一个接口的子类对象

 

 

 

 

正则表达式

       正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编辑器里，正则达表示通常被用来检索、替换那些符合某个模式的文本。

        用到的String类的方法:            

               public boolean matches(String regex) 判断此字符串是否匹配给定的规则

               public String[] split(String regex) 将此字符串按照指定的规则进行切割

               public String replaceAll(String regex,String replacement) 将满足规则的字符串用给定字符串所替代

 

         常见规则

regex="[123ABCabc]";//允许出现1，2，3中任意一个
                regex="[^123]";//除了123其他都可以
                regex="[0-9]";
                regex="[a-z]";
                regex="[A-Z]";
                regex="[0-9a-zA-Z]";
                regex=".";//匹配任意单个字符
                regex="\\.";//我想让.代表这个.本身 需要对点进行转意
                regex="\\d";//表示[0-9]
                regex="\\w";//表示 [a-z_A-Z]
                regex="a?b?";//一次或一次也没有 ""空串就代表0次
                regex="a*";//零次或多次  大于等于1次 都算多次
                regex="a+";//至少一次，或多次
                regex="\\w+";
                regex="[0-9]{5}";//正好出现几次
                regex="[a-z]{5,}";//至少5次
                regex="[a-zA-Z0-9]{6,18}";//表示6到18

                String mailRgex="[a-zA-Z0-9]{6,16}@[a-z0-9]{2,16}\\.(com|cn|net|org)";
                //匹配这个正则
                boolean b = "abddfdfdffd".matches(regex);
                System.out.println(b);

                split();截取    "91 27 46 38 50”返回91,27...