java从白纸到废纸（自学笔记）

基础知识、日后补充。

零碎知识总结

一、什么是面向对象

是一种变成思想；

面向对象是相对于面向过程的

核心理念：谁的功能谁负责

面向过程：遇到问题，亲力亲为，一步步实现（小兵思想）

面向对象：遇到问题，找具有解决这个问题的对象，调用对象的方法（老板思想）

面向对象有三大特点:封装(安全性),继承(扩展性),多态(灵活性)

 

 

一个标准的类

1、  封装：隐藏实现细节，对外暴露公共访问方式

2、  构造：无参（必须有） 全参数（最好有）

3、  toString（快速打印对象信息）

4、  hashCode和equals（保证元素使用哈希表结构存值时的唯一性）

二、java中的数据类型

 

 1.基本数据类型:四类 八种

                 byte(1) boolean(1) short(2)char(2) int(4) float(4) long(8) double(8)

对应包装类：Byte Boolean Short Character Integer Float Long Double

 

 2.引用数据类型

                 String , 数组,集合ArrayList,Scanner,Random,自定义类型

 

 三、引用数据类型String中的方法(4532)

 

 第一组:判断方法

                 boolean equals(String str);//比较两个字符串的内容是否相等

                 boolean equalsIgnoreCase(Stringstr);//比较两个字符串的内容是相等(忽略大小写)

                 boolean startsWith(String subStr);//判断某个字符串是否以指定的子串开头

                 boolean endsWith(StringsubStr);//判断某个字符串是否以指定的子串结尾

 第二组:获取方法

                 int length();//获取字符串中字符个数

                 char charAt(int index);//获取字符串中某一个字符

                 String substring(intstartIndex);//从指定下标开始截取字符串,直到字符串的末尾

                 String substring(int startIndex,intendIndex);//从指定下标开始截取字符串,到指定下标结束(包括开头不包括结尾)

                 ---可忽略  int indexOf(String subStr);//获取子串第一次出现的下标

 第三组:转换方法

                 String toLowerCase();//转成小写串

                 String toUpperCase();//转成大写串

                 Char[] toCharArray();//变成字符数组

 第四组:其他方法

                 String trim();//去掉字符串两端的空格

                 String[] split(String str);//切割字符串

 

 三:流_读写文件

                 输出流:数据从java程序 到  文件中

                 FileWriter:文件的字符输出流,写数据(一个字符,一个字符串,一个字符数组)

                           write(int ch);//写一个字符(可以写字符的ASCII码值)

                           write(char[] chs);//写一个字符数组

                           write(String s);//写一个字符串

                           write(char[] chs,intstartIndex,int len);//写一个字符数组的一部分

                           write(String s,intstartInex,int len);//写一个字符串的一部分

 

                 输入流:数据从 文件 到java程序

                 FileReader:文件的字符输入流,读数据(一个字符,一个字符数组)

                           int read();//读取一个字符

                           int read(char[]chs);//一个读取一个字符数组,返回值表示实际读取到的字符的个数

                          

                 文件的路径分为两种:

                 1.相对路径:

                           相对于当前项目而言的

 

                 2.绝对路径:

                           以盘符开头  C: D:

    四:对象的内存图:

                 Dog d = new Dog();

                 d是引用数据类型,保存到栈(stack)中

                 new Dog();创建对象,保存到堆(heap)中

  五:this的作用以及本质

       作用:区分局部变量和成员变量的同名的情况

       本质:this代表一个对象,具体是哪一个对象,那么由方法的调用者决定

This：代表当前类的对象

       Super：代表父类对象

  this:区分成员变量和局部变量的同名情况

  super:区分子类成员变量和父类成员变量同名的情况

 

  用法:

      this.xxx: 访问本类的成员变量

      this.aaa();调用本类的成员方法(this可以省略)

 

   super.xxx: 访问父类的成员变量

   super.aaa();调用父类的成员方法(super不能省略)

  

   高级使用: this和super的语句形式

            this(参数); 用来调用本类的其他构造

                    其他构造是指哪一个构造?  有this()中的参数决定

              this的作用？

答：（1）区别局部变量和成员变量（2）代表本类对象的引用（3）也可以用于构造方法的调用。

 

  六:匿名对象:

       语法: 只创建对象,而不是变量来接收

                比如: new Dog(); newStudent()

       特点:一个匿名对象只能使用一次,第二次使用就是一个新的匿名对象

  一、继承

  1.概念:

                描述两个类之间的关系(子类和父类之间的关系)

                一个类(子类) 在另外一个类(父类)的基础上创建,那么这个过程就叫做继承

  2.语法:

                public class 父类{}

                public class 子类 extends 父类{}

  3.继承的作用:

                子类自动拥有父类的可继承(非private修饰的)的成员变量和成员方法

                提高了代码的服用性

  4.继承中子父类的成员变量和成员方法的特点:

                如果子父类中出现了同名的成员变量或者成员方法

                         通过子类对象调用成员变量或者成员方法时,优先调用子类自己的,如果子类没有,再去访问父类的

  5.java中继承的特点:

                1.java只支持单继承: 一个子类 只能有一个直接父类

                2.java中支持多层继承 父类可以有父类

                3.子类自动拥有父类的可继承(非private修饰的)的成员变量和成员方法

4.如果子类继承了父类,那么子类会自动拥有父类中所有的成员(但是private除外,父类中用private修饰成员子类不能直接拿过来用)

                   5.继承的作用: 提高的代码的复用性

.6、父类定义了继承树中共性内容，子类定义了该类个性内容

继承中子父类的成员变量的特点:

                 1.子父类的成员变量不同名时,没有任何问题

                 2.子父类的成员变量同名时, 使用子类的对象访问该成员变量时,优先访问子类自己的

 

 

 继承中子父类的成员方法的特点:

                 1.子父类的成员方法不同名时,没有任何问题

                 2.子父类的成员方法同名时,使用子类的对象调用该成员方法时,优先调用子类自己的

           结论:

                 无论是调用成员方法还是访问成员变量

                           优先访问子类自己的,如果子类没有,再去访问父类的,如果父类也没有那就报错

      

        

二、抽象类

1.方法的重载(overload):

       在同一个类,方法名相同,但是参数列表不同,这时候这几个方法被称为方法的重载

             参数列表不同:

             参数个数不同,参数类型不同,参数顺序不同

                   

 

 2.方法的重写(override,覆盖,覆写):

             在继承中,子类出现了和父类一模一样的方法,那么子类中这个方法被称为方法的重写，方法头必须一样（修饰符范围大于或等于原方法的修饰符范围）。

出现的情景：普通类 抽象类 接口

                                         

 

抽象类:

                   Java中规定,只要一个类是用abstract修饰 ,那么这个类就是抽象类

                   特点:

                            java规定,抽象类不能创建对象

                   抽象类不能创建对象,有什么作用?

                            抽象类天生就是作为父类

                           

        

抽象方法:

                   一个方法,如果只有声明,没有实现 那么这个方法就是抽象方法

 

                   抽象方法产生的?

                            当子类的共性不断向上抽取,抽取到一定程度,有些方法我们就不知道如何实现

                            那么我们就把这个方法称为抽象方法

 

格式:

                   抽象方法必须由 关键字 abstract修饰

                            publicabstract void work();

                   抽象类 必须由关键字 abstract修饰

                            publicabstract class 类名{}

 

注意        

（共性的抽取）

              关键字：abstract

                     1 父类

                     2 不一定有抽象方法

                     3 无法直接创建对象,有构造方法

                     4.抽象方法 没有方法体

              abstract不能和哪些关键字共同存在？

答：private：私有的方法是不可见的，无法被复写

                     final：被final修饰的方法是最终方法，无法被复写

       static：被static修饰的方法，随类加载到方法区，由于抽象方法没有方法体所以不能加载

 

       final、finally、finalized的区别？

答：（1）final是一个关键字，是用来修饰类，成员变量，成员方法的，

                            它修饰的类不能被继承，但是可以继承其他类，

                            它修饰的成员变量是一个常量，只能赋值一次

                            它修饰的成员方法不能被子类重写

（2）finally是 try-catch-finally语句的一个模块，正常情况下里边的代码永远会执行，一般是用来释放资源的

（3）finalize是Object类中的方法，当对象变成垃圾的时候，由GC(Java中的垃圾回收机制)来调用该类的finalize()方法回收垃圾。

三、接口

1. 类的概念:

                 一堆具有共同的成员变量/属性和成员方法/功能对象集合

 

 2 .接口的概念:

                 接口是功能的集合,就是方法的集合

                 也就是说 接口中只能定义方法,不能定义普通的成员变量

 

                 而且接口中的成员方法,必须都是抽象的

                 我们一般这么理解,接口是比抽象类 还有抽象一种类型

 

                 问题:接口能创建对象吗? 不能

                           接口有什么用? 天生作为"父接口"

 3.接口的定义

                 定义类用关键字:class

                 定义抽象类用关键字:abstractclass

 

                 定义接口用关键字:interface

                 定义枚举用关键字:enum

 

             格式:

                 public interface 接口名字{

                           //成员变量,不能定义普通的成员变量

                           //成员方法:必须都是抽象

                           public abstract 返回值类型 方法名();

 

                 }

                

                 类和接口的本质区别并不大,他们的源码都是.java文件

     编译后都是.class文件

 4.各种类型之间的关系

                 ａ．类和类之间:继承,而且是单继承,一个子类 只能有一个直接父类

                

                 ｂ．接口和接口之间:继承,但是可以多继承,一个子接口 可以有多个直接父接口

 

                 面试题:java到底支不支持多继承？

                           如果是类与类　不支持多继承，只支持多层继承

                           如果是接口和接口　支持多继承，也支持多层继承

                 ｃ．类和接口之间: 不叫继承(extends),叫实现(implements),可以多实现

                                             只有 类 实现 接口

                          

                           实现:implements和 继承 差不多, 实现是把接口中的抽象方法都拿过来

 5.接口中成员的特点

                 5.1成员变量,但是必须有固定修饰符 public static final数据类型 变量= 值

                 5.2成员方法,必须是是固定修饰符 public abstract （可以省略）即 抽象方法

                 5.3接口不可以创建对象(抽象类也是)

                 5.4实现类 实现类接口 ,那么必须重写接口中所有的抽象方法,然后才能创建对象

                           否则 这个实现类 还是一个抽象类,是不能创建对象的

 

在开发中最常用的模式:

                           一个类 继承 一个抽象类, 同时 实现多个接口

                           public class A extendsAbstractClassB implments 接口A,接口B{

                                    注意:

                                    A类中必须重写 抽象类中的抽象方法,以及所有接口中的所有抽象方法

接口和抽象类的异同

 *

  1.相同点:

 *           a.都不能创建对象

 *           b.都是作为父类/父接口

 *           c.子类/实现类 都必须重写抽象方法,然后才能创建对象

  2.不同点:

 *           a.抽象类用关键字 abstract接口用关键字interface

 *          b.抽象类中可以有抽象方法,可以没有抽象方法,也可以有部分是抽象方法,部分不是抽象方法

 *                  接口中只有有方法,必须都是抽象的

 *          c.抽象类可以定义任意成员变量 接口的成员变量必须public static final修饰

 *           d.类和抽象类之间关系是单继承,类和接口之间关系是多实现

 *           e.思想上的区别

 *                  1.抽象类中 必须定义 整个继承体系的共性内容

 *                  2.接口中定义 整个继承体系之外的 额外的扩展的功能

四、多态

面向对象有三大特点:封装(安全性),继承(扩展性),多态(灵活性)

* 多态:

 *           是指对象的多态

 *                  一个对象 的多种状态

*                   比如:一只狗  是狗,是动物,是生物

 *                  比如:一个人 是人,是动物,是生物

 *                  比如:你 在学校是学生,在家里是儿子,在公司员工,在外面老大

 *           在java中的多态

 *                  前提:

 *                         1.必须有子父类关系 (必须有继承)

 *                         2.必须有方法的重写

*                   多态在java中表现形式:

 *                         父类类型 变量名 = new 子类类型();

 *                         父类类型的变量 指向了 子类的对象

 

 *                 方法中的参数类型可以用多态这样就可以传入该父类下所有的子类类型

 

 *                         public class Animal{}

 *                         public class Dog extendsAnimal{}

 *                         public classBigYellowDog extends Dog{}

 *                         代码体现:

 *                         Dog d = new Dog();

 *                         Animal an = new Dog();

 *                         多态的形式创建一个大黄狗对象

 *                         Dog d =  new BigYellowDog();

 *                         Animal an = newBigYellowDog();

多态中的注意事项         

 * 什么叫多态:

 *           一个对象的多种形态

 1.两个前提:

 *           1.必须有继承

 *           2.必须有方法重写

 *           3.代码体现:

 *                  父类类型 变量名 = new子类类型();

 *

 2.注意事项:

 *           使用多态调用成员变量

 *                   编译时 看父类看左边

 *                   运行时 看父类看左边

 *

 *           使用多态调用成员方法

 *                  编译时 看父类 看左边

 *                  运行时 看子类 看右边

 *

 3. 总结:

 *           多态使用变量编译运行都看父类

 *           多态调用方法编译看父类 运行看子类

 *

 4.多态的弊端:

 *           多态只能调用子父类共有的方法,不能调用子类特有的方法

 5. 结论:

 *     多态调用成员变量时,编译运行都看父类

 *

 *    多态调用成员方法时,编译看父类 运行看子类

 *

 *    弊端:多态只能调用子父类共有的方法, 不能调用子类特有的

 *

 *  好处:提高程序的灵活性

 *          案例:定义三个方法 喂狗,喂猫,喂猪,喂老虎

 *  总结:

 *          父类类型的变量,可以接收 任何一个子类的对象

 *          调用方法的时候,编译是看父类,运行时运行的传递过来的子类对象中的方法

 *

 6.多态弊端的解决方案:

 *           向下转型:强制类型转换 inta = (int)3.14;

 *

 *           向上转型(就是多态): 自动类型转换 double d = 10;

 *                  Animal an = new Dog();

 *

 7.向下转型也有弊端:

 *           把父类的变量转成子类类型的时候 编译器直接编译通过*             

向下转型过程中 很容易出现  类型转换的异常 Cat can notbe cast to Dog

 

 *

 * java中解决向下转型弊端的方法:

 *           一个关键字instanceof 运算符

 *

 *           作用:判断某一个变量 不是 该类的类型

 *           格式:

 *                  boolean b = an instanceof类名

 *

 * 总结:

 *           多态的好处:提高程序的灵活性,扩展性,复用性

 *                         因为父类的变量 可以接收任何一个子类对象

 *           多态的弊端:

 *                         不能调用子类特有的方法

 *           向上向下转型:

 *                  向上转型:多态

 *                  向下转型:子类类型 变量名 =(子类类型)父类类型的变量;

 *                                变量名.子类特有方法();

  *         关键字:运算符instanceof

 *                  判断某一个对象是不是属于一个类

 *                  格式:

 *                          boolean b = 变量名instanceof 类名

 

五、Static、final修饰符

static

1、static:关键字,静态的

         static的作用是用来修饰类中的成员

修饰的东西属于类，不属于对象。被所有对象共享。

 

 

 2.以前我们要访问一个类中的某一个成员变量

                 需要先创建对象,在通过对象调用成员变量

 

 3.如果一个类的成员变量static修饰了,那么想访问这个成员

                 直接通过类名.成员变量

访问方式： 类名.方法名（）

                对象.方法名（） 不推荐 如果static修饰的内容被改变 再次调用的时候是改变之后的结果

静态代码块的格式:

             在类的成员位置

                    static{

                           写一句或者多句代码

                    }

             特点:

             1.当我们使用到这个类的时候,JVM自动执行静态代码块

             2.只会执行一次,而且在第一次使用到这个类的时候执行,第二次使用不会执行了

             3.静态代码块的优先级,很高,比构造方法高,比main方法高

             4.静态代码块什么用?

用来初始化类的,mysql数据(静态代码块来加载驱动)

/

final:最终的,终极的 

 final可以修饰类,成员变量,成员方法,局部变量(基本类型,引用类型)

 

1、final修饰类

(太监类): 不能被继承, 但是并不是不能作为其他类的子类

 

 2.final修饰成员变量:

             2.1被final修饰的成员变量,必须在创建对象之前有确定的值

             2.2被final修饰的成员变量,只能赋值一次

 

 3.final修饰成员方法(牛逼方法):

             不能被子类重写

 4.final修饰基本类型局部变量:

             被final修饰的基本类型局部变量 只能赋值一次

 5.final修饰引用类型的局部变量

             被final修饰的引用类型局部变量 只能赋值一次

             但是引用类型所指向的对象中内容是可以改变的

 

 

 

四种权限修饰符

Private<default<protected<public

l  要想仅能在本类中访问使用private修饰；

l  要想本包中的类都可以访问不加修饰符即可；

l  要想本包中的类与其他包中的子类可以访问使用protected修饰

l  要想所有包中的所有类都可以访问使用public修饰。

l  注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

 

六、匿名内部类:

                   是一种特殊的语法,用来快速创建抽象类的子类对象

                                                用来快速创建  接口的实现类对象

                  

不用匿名内部类:

                   给你一个抽象类,要求创建该类的子类对象

                   1.创建子类,继承抽象类

                   2.重写抽象类中的所有抽象方法

                   3.new子类对象

                   给你一个接口,要求创建该接口的实现类对象

                   1.创建实现类implments 接口

                   2.重写接口中所有的抽象方法

                   3.new实现类对象

 

 

         public static voidtest01(){

                   //使用匿名内部类快速 创建AbstractAnimal抽象类的子类对象

                   //第一种方式

                   new AbstractAnimal(){

 

                            @Override

                            public voideat() {

                                     // TODOAuto-generated method stub

                                     System.out.println("吃");

                            }

 

                            @Override

                            public voidsleep() {

                                     // TODOAuto-generated method stub

                                     System.out.println("睡");

                            }

                           

                           

                   };

                   //第二种

                   new AbstractAnimal(){

                            @Override

                            public voideat() {

                                     // TODOAuto-generated method stub

                                     System.out.println(".....");

                            }

                            @Override

                            publicvoid sleep() {

                                     // TODOAuto-generated method stub

                                     System.out.println("!!!");

                            }

                   }.sleep();

                   //第三种

                   AbstractAnimal an1 =  new AbstractAnimal(){

 

                            @Override

                            public voideat() {

                                     // TODOAuto-generated method stub

                                     System.out.println("吃吃吃");

                            }

 

                            @Override

                            public voidsleep() {

                                     // TODOAuto-generated method stub

                                     System.out.println("睡睡睡");

                            }

                           

                   };

                  

                   an1.eat();

                   an1.sleep();

         }

匿名对象：

只使用一次

匿名内部类：

格式：

匿名对象:  new 类名（）；

匿名内部类：父类或接口  变量 =  new 抽象类或者接口（）{重写方法}；

 

注意：匿名内部类必须继承或实现一个接口，在使用的时候直接用父类的名字创建一个子类对象并实现其中的方法，匿名内部类实质是一个继承了该类或者实现该接口的匿名的子类对象。 

七、异常:

是java代码编译或者运行过程中出现的问题

                

 异常的继承体系:

        Throwable:可以抛出去的东西

                 --Exception:异常(普通问题)

                           相当于人类的  感冒,发烧,口腔溃疡.

                 -- 编译时异常:编译的时候 出现的问题

                                    指的是Exception 以及 Exception子类(RuntimeException除外)

 

                 -- 运行时异常:编译的时候  是没有问题的,运行的时候出现了问题

                                    指的是RuntimeException 以及 RuntimeException的子类

                 --Error:错误(严重的问题)

                           比如:OutOfMemoryError:超出内存错误

                           如果程序出现了错误,只能改代码

                           相当于人类的 不治之症

处理异常的方式:

 

 1.不处理:再次声明抛出

                 throw:动词,真正的抛出一个异常对象

                 throws:形容词,用来形容方法,表示某一个方法 可能抛出xx异常,要求调用者去处理它

                           格式:

                                    public 返回值类型 方法名(参数)throwsxxxException{

 

                                    }

 

 2.捕获处理

                 try{

                           可能出现异常的代码

                 }catch(Exception e){

                           //处理异常

                 }finally{

                           //写上必须要执行的代码

                           //释放资源的代码

                 }

 3.其他的处理方式

                   多个异常分别处理(很少用的)

                   多个异常一次捕获多次处理(很少用)

                   多个异常一次捕获一次处理(常用)

       Object类

              Equals：比较的是对象的地址值。

              toString：将对象以字符串的形式输出（对象的类型+@+内存地址值。）

       异常：

              分类：throwable  （error         exception（编译异常 运行时异常））

 

              处理：throws   try catch

 

              自定义异常：继承Exception和继承RuntimeException

 

              Throw 和throws的区别：

                     位置：Throw在方法体中，throws在方法上。

                     使用：throw 只能抛出一个异常对象，throws可以抛出多个异常类

运行异常和编译异常的区别？

答：所有的RumtimeException类及其子类的实例是运行异常，其他异常时编译异常。编译异常必须显式处理，否则会编译失败。运行时异常可以不处理，可以通过编译。

 

子父类间异常的注意事项？

答：（1）子类继承父类时，父类方法抛出了异常，子类重写该方法时只能抛出相同的异常或者该异常的子类。

（2）如果父类抛出了多个异常，子类在重写方法时只能抛出相同的异常或者他的子集，不能抛出父类没有的异常。

（3）如果父类没有抛出异常，子类重写该方法时不能抛出异常。如果子类出现了异常，只能进行try处理，不能抛出。

八、一些常用类

1.Date类:日期类

                 构造:

                 public Date();//代表当前系统时间的Date对象

                 public Date(long time);//代表距离标准时间 time毫秒值的Date对象

                 成员方法:

                 public String toString();//Date          重写Object类的toString方法

                 public long getTime();//获取当前Date对象的毫米值

 

 2.DateFormat:日期格式化类,他是一个抽象类

                 具体的子类:SimpleDateFormat

                 构造:

                 public SimpleDateFormat(Stringpattern);//以指定的模式创建格式化对象

                 成员方法:

                 public String format(Date d);//把date对象按照指定的模式 转成字符串

                 public Date parse(String s);//把字符串转成Date对象,如果字符串有问题,就会抛出ParseException

 3.Calendar:日历类

                 3.1获取Calendar对象

                           public static CalendargetInstance();//返回的是抽象类Calendar的某一个子类

                 3.1成员方法:

                           public int get(intfield);//获取指定字段的值

                           public void add(intfield,int amount);//给指定的字段增加值

                           public void set(intfield,int value);//修改指定字段的值

                           public DategetTime();//把Calendar对象转成Date 对象

 4.System:系统类

                 public static void exit(0);//结束JVM

                 public static void gc();//通知垃圾回收器过来收垃圾

                 public static getProperty(Stringkey);//根据键获取值

                 public static longcurrentTimeMillis();//获取当前系统的毫秒值

 5.Math:数学类

                 1.求最大值 2.求最小值 3.求绝对值   4.求随机数  5.求四舍五入

                 6.ceil(向上取整)7.floor(向下取整) 8.pow(求次幂)

 6.基类数据类型包装类

                 (8中基本类对应的包装类型)

                 (自动拆箱装箱)

 7.正则表达式:

                 boolean b = "普通字符串".matches("正则表达式");

注意

1.==和equals的区别？

       答：“==”是比较运算符，既能比较基本数据类型，又能比较引用数据类型。基本数据类型比较的是数值，引用数据类型比较的是地址值。

equals是一个方法，只能比较引用数据类型。所有的类都会继承Object的equals方法。重写equals方法比较的是对象的内容，如果没有重写将调研Object的equals方法，比较的是地址值。

 

2.String str = null 和String str = “”的区别？

       答：String str = null只是声明了引用，但是没有创建对象，没有为其开辟空间，不能操作方法。String = “”是创建了一个长度为0的字符串，并在内存中分配了空间。

 

3．String s1= “abc”, String s2= new String(“abc”),s1==s2结果是什么？s1.equals(s2)结果是什么？

       答：s1==s2结果为false。s1指向的常量池中的对象，s2指向的是堆内存中的对象，两者的地址值不同。s1.equals(s2)结果是true。String重写了equals方法，比较的是内容。