java基础之正则及面向对象

1. 正则表达式：其实是用来操作字符串的一些规则。
好处：正则的出现，对字符串的复杂操作变得更为简单。

特点：将对字符串操作的代码用一些符号来表示。只要使用了指定符号，就可以调用底层的代码对字符串进行操作。符号的出现，简化了代码的书写。

弊端：符号的出现虽然简化了书写，但是却降低了阅读性。
其实更多是用正则解决字符串操作的问题。

组：用小括号标示，每定义一个小括号，就是一个组，而且有自动编号，从1开始。
只要使用组，对应的数字就是使用该组的内容。别忘了，数组要加\\。
(aaa(wwww(ccc))(eee))技巧，从左括号开始数即可。有几个左括号就是几组。

2. 常见操作：
1、匹配：其实用的就是String类中的matches方法。
String reg = "[1-9][0-9]{4,14}";
boolean b = qq.matches(reg);//将正则和字符串关联对字符串进行匹配。

2、切割：其实用的就是String类中的split方法。

3、替换：其实用的就是String类中的replaceAll();

4、获取：
    <1> 先要将正则表达式编译成正则对象。使用的是Pattern中静态方法 compile(regex);
<2> 通过Pattern对象获取Matcher对象。
Pattern用于描述正则表达式，可以对正则表达式进行解析。
而将规则操作字符串，需要从新封装到匹配器对象Matcher中。
然后使用Matcher对象的方法来操作字符串。
如何获取匹配器对象呢？
通过Pattern对象中的matcher方法。该方法可以正则规则和字符串想关联。并返回匹配器对象。
<3> 使用Matcher对象中的方法即可对字符串进行各种正则操作。

3. 静态：
1、Static  是一个修饰符，用于修饰成员（成员变量 、成员方法）

2、当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用 
      格式：类名.静态成员

3、Static特点：
           <1>、随着类的加载而加载。  也就是说：静态会随着类的消失而消失，说明它生命周期最长。
           <2>、优先于对象存在  。明确一点：静态先存在 对象后存在。
           <3> 被所有对象共享 ,
           <4> 可以被类名所调用

4. 实例变量和类变量的区别：
           1、存在位置：
                         类变量随着类的加载而存在于方法区中。
                         实例变量随着对象的建立而存在于堆内存中。

           2、生命周期:
                         类变量的生命周期最长，随着类的消失而消失。
                         实例变量的生命周期随着对象的消失而消失。

5. 静态使用注意事项：
           1、静态方法只能访问静态成员。
                   非静态方法既可以访问静态也可以访问非静态
           2、静态方法中不可以定义this,super关键字。
                   因为静态优先于对象存在。所以静态方法中不可以出现this。
           3、主函数是静态的。

6. 静态的利弊端：           
           利处： 1、对对象的共享数据尽享单独空间的存储，节省空间，没有必要没一个对象都存储一份。
                        2、可以直接被类名调用。
          
  弊端： 1、生命周期过长。
                        2、访问出现局限性。（静态虽好，但只能访问静态）

7. 主函数：
1、定义： 是一个特殊的函数，作为程序入口，可以被jvm调用。

2、涵义：
           public: 代表着该函数的访问权限是最大的。
           static: 代表主函数随着类的加载就已经存在了。
           void: 主函数没有具体的返回值。
           main:不是关键字，但是是一个特殊的单词，可以被jvm识别。
           (String[] args)：函数的参数，参数类型是一个数组，该数组的元素是字符串。字符串类型数组。

3、主函数是固定格式的 ，被jvm识别。

8. 什么时候使用静态：
1、什么时候定义静态变量（类变量）呢？
      <1> 当对象中出现共享数据时，该数据被静态所修饰。
    <2> 对象中特有的数据要定义成非静态存在于堆内存中。

2、什么时候定义静态函数呢？
    当功能内部没有访问到非静态数据（对象特有数据），则可定义成静态函数。

9. 静态的应用：
        1、每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。
      
2、将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象。
             为了更严谨，强制让该类不能建立对象，可以通过将构造函数私有化完成（private）
     
       （默认构造函数的权限是随着类的变化而变化的）

10. 静态代码块：
       格式：
            static
            {
                  静态代码块中的执行语句
            }
        特点：随着类的加载而执行，只执行一次并优先于主函数。 用于给类进行初始化。

11. Persong   p  = new  Person("XX",XX);
这句话执行了：
   1、因为new用到了Person.class，所以会先找到Persong.class文件并加载到内存中
  
   2、执行该类中的static代码块，如果有的话，给Person.class类进行初始化
   
   3、在堆内存中开辟空间，分配内存地址
   
   4、在堆内存中建立对象特有属性，并进行默认初始化
   
   5、对属性进行初始化
   
   6、对对象进行构造代码块初始化
   
   7、对对象进行对应的构造函数初始化
   
   8、将内存地址赋给栈内存中的p变量

12. 构造代码块：
    作用：给对象进行初始化。
    
    对象一建立就运行，而且优先于构造函数执行。
    
    和构造函数的区别：
    
    构造代码块是给所有对象进行统一初始化
    
    构造函数是给对应对象初始化

13. 静态代码块和构造代码块：
  相同点：都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，
　　　　一般在代码块中对一些static变量进行赋值。
  
  不同点：静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。
　　　　静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new一次就执行一次。
　　　　非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行

14. 想要保证对象唯一：]
      饿汉式(先初始化对象，Student类一进内存就创建好了对象)
1、将构造函数私有化  

2、在类中创建一个本类对象      

3、提供一个方法可以获取到该对象 
    
private Student() {};
private static Student s=new Student();
public static Student getInstance()  {return s};

   懒汉式（延时加载  Student类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象

        private static Student s = null;
        private Student(){}
        public static Student getInstance()
        {
                if(s==null)
                    s=new Student();
                     return s;
        }

15. 继承：
1、提高了代码的复用性。

2、让类与类之间产生了关系。有了这个关系，才有了多态的特性。

3、注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属的关系才可以继承。所属关系 is  a

4、Java语言中，Java只支持单继承，不支持多继承。   因为多继承容易带来安全隐患：当多个父类中定义了相同的功能，当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制，并用另一种体现形式来完成表示（多实现）

5、java支持多层继承。也就是一个继承体系  

16. 如何使用一个继承体系中的功能呢？
   想要使用体系，先查阅体系父类的描述，，因为父类中定义的是该体系中共性功能，通过了解共性功能，就可以知道该体系的基本功能。
   
   那么这个体系已经可以基本使用了。
   
   那么在具体调用时，要创建最子类的对象，为什么呢？
1、因为有可能父类不能创建对象

2、创建子类对象可以使用更多的功能，包括基本的也包括特有的
          简单一句话：查阅父类功能 ，创建子类对象使用功能。

17. 子父类出现后，类成员的特点：
1、变量
如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this;访问父类中的同名变量 用super。super的使用和this的使用几乎一致。this代表的是本类对象的引用；super代表的是父类对象的引用。

2、函数
当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性： 重写（覆盖）
  
当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类的不一致这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能的内容。
   
覆盖（重写） 注意事项：
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。静态只能覆盖静态。重载：只看同名函数的参数列表。重写：子父类方法要一模一样。 

3、构造函数 
    在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句 super（）。super（）：会访问父类中的空参数构造函数。而且子类中所有的构造函数默认第一行都是super( )。
    
为什么子类一定要访问父类中的构造函数？
  因为父类中的数据子类可以直接获取。所以子类对象在建立时需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义

Super语句的方式来指定。
  注意：super语句一定定义第一行。

18. 子类的实例化过程：
  结论： 子类的所有构造函数，默认都会访问父类中的空参数构造函数 ; 因为子类中每一个构造函数内的第一行都有一个隐式的super（）；当父类中没有空参数的构造函数时，子类必须手
动通过super语句的形式来指定要访问父类中的构造函数。
  
  当然：子类的构造函数第一行也可以手动指定this语句来访问本类构造函数；子类中至少有一个构造函数会访问父类中的构造函数。

19. final作为一个修饰符： 
1、可以修饰 类、函数、变量。

2、被final修饰的类不可以被继承。是为了避免被继承，被子类复写的功能。

3、被final修饰的方法不可以被重写。

4、被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。 

当在描述事物时，一些数据的出现值是固定的，那么这是为了增强阅读性，都给这些值起个名字，方便于阅读。 而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。

6、内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

20. 抽象类的特点：
  1、抽象方法一定在抽象类中

2、抽象方法和抽象类都必须被abstract关键字修饰
 
3、抽象类不可以用new创建对象，因为调用抽象方法没意义
 
4、抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用； 如果子类只覆盖了部分的抽象方法，那么该子类还是一个抽象类。
 
5、抽象类中可以有抽象方法也可以有非抽象方法
 
6、抽象类和一般类没有太大的不同：   该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂得东西。这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体
 
7、抽象类比一般类多了个抽象函数，就是在类中可以定义抽象方法; 抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让改类建立对象。

模板方法：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。有该类的子类去实现。

21. 接口：
初期理解：可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示 （interface）

接口定义时，格式特点：
1、接口中常见定义：常量，抽象方法。

2、接口中的成员都有固定修饰符。  
        常量：public static final
        方法：public abstract
记住：接口中的成员都是public的。

3、接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。       
接口可以被类多实现，也是对多继承不支持的转换形式，Java支持多实现。     

22. 多态：
可以理解为事物存在的多种形态。
1、多态的体现：父类的引用指向了自己的子类对象。父类的引用也可以接受自己的子类对象。

2、多态的前提：必须是类与类之间有关系。要么继承；要么实现。通常还有一个前提：存在覆盖。

3、多态的好处：多态的出现大大的提高了程序的扩展性。

4、  多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5 、 多态的应用

6、多态的出现代码中的特点（多态的使用注意事项）
  <1> 在多态中成员函数的特点(非静态)：在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，则编译通过；没有，则编译失败。在运行时期：参阅对象所属的类中是否有调用的方法。
  简单总结就是：多态函数在多态调用时，编译看左边，运行看右边。
 
<2> 在多态中 成员变量的特点：无论是编译还是运行，都参考左边（引用型变量所属的类）
 
<3> 在多态中，静态成员函数的特点：无论编译和运行，都参考左边。

23. Object: 是所有对象的直接或者间接父类，传说中的上帝该类中定义的肯定是所有对象都具备的功能

Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义；只要沿袭父类中的功能，建立自己特有的比较内容即可。这就是覆盖。

24. 内部类的访问规则：
1、内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式 外部类名.this

2、外部类要访问内部类，必须要建立内部类对象。

3、访问格式：
<1> 定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象。格式：外部类名.内部类名 变量名= 外部类对象.内部类对象Outer.Inner in =new Outer().new Inner() ;

<2> 当内部类在成员位置上时，就可以被成员修饰符所修饰。比如： private：将内部类在外部类中进行封装static:内部类就具备static特性。当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限性。
 
<3> 在外部其他类中，如何直接访问static内部类的非静态成员呢？new Outer.Inner().function();在外部其他类中，如何直接访问static内部类的静态成员呢？Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。当外部类中的静态方法访问内部类时，内部类也必须是静态的

4、在描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部类事物在使用外部事物的内容。

5、内部类在定义局部时：
    <1> 不可以被成员修饰符修饰。
   
<2> 可以直接访问外部类中的成员，因为还持有外部类中的引用;但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
      
25. 匿名内部类：
1、匿名内部类其实就是内部类的简写格式。

2、定义内部类的前提：内部类必须继承一个类 或者实现接口。

3、匿名内部类的格式：new 父类或者接口( )  {定义子类的内容}

4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5、匿名内部类中定义的方法最好不要超过3个。

26.包：
总结：1、包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。

2、不同包中的子类还可以直接访问父类中被protected权限修饰的成员。 包与包之间可以使用的权限只有两种：public protected

3、为了简化类名的书写，使用一个关键字 import；Import导入的是包中的类。建议：不要使用通配符*，需要用到包中的哪个类，就导入哪个类

4、建议定义包名不要重复，可以使用url来完成定义,url是唯一的。