Java基础OOP笔记

1、 short s = 1;
//s += 1;
s = (short)(s + 1); //s = s + 1;  s为short，1为int，需要强制转换为short。

容量自动小转大，大强制转小

     byte,short,char->int->long->float->double boolean   1位
字节  1  ,2    ,2   ->4  ->8   ->4    ->8 


2、
&&   与（短路与）  操作数只能是布尔型 一假则假

如果&&前面的表达式为假，则后面的表达式不会被执行。

|| 或（短路或）  操作数只能是布尔型 一真则真

如果||前面的表达式为真，则后面的表达式不会被执行。

& 逻辑与（按位与） 如果操作数是数值，则先转换成二进制，再对其每一位进行与操作。

| 逻辑或（按位或） 同上

^ 异或（按位异或） 相同为False（0），不同为True(1)。


3、运算符的优先级：一算关逻条赋

4、比较if与switch的区别：
相同点：都可以实现分支结构。
不同点：switch只能处理等值的条件判断，且条件是整形变量或字符变量或字符串变量的等值类型
（byte short int  char String(java7后增加的新特性)）
多重if在else部分还包含其他if结构，特别适合某个变量处于某个区间的判断。

5、for each循环：
功能等同于for循环，可以遍历数组中所有数据，但是不必使用数组的下标

for(数组元素数据类型 变量名:数组名)

6、从控制台接受参数
两种方式：
一是Scanner类；
二是main方法中的String[]参数
案例：获取控制台输入的参数，存储在main方法的参数中，并打印输出   
 命令行输入参数执行语法：
 java class名称 参数1 参数2 .....参数n
 eclipse中带参数运行
 run as->run configuration->arguments 
 输入参数，多个用回车间隔


7、数组的声明
int[] b = new int[10]; 

int d[] = {23,45};

8、面向对象编程
OOP Object Oriented Programing
三大原则：封装、继承、多态
对象的两个特征：属性（特征）和方法（行为）

封装： 对象和属性和方法常被封装在一起
他们共同体现对象的特性，相辅相成，不能分割

抽象： 将相同或相似的对象归为一类的过程，抽象是分析问题

类：是模板，确定对象将会拥有哪些属性和方法
类是引用类型，非原始数据类型

9、类与对象的区别
类与对象的关系：一对多的关系
类是抽象的概念，或者是个模板，用来表示对象的共性；
对象是个看得见摸得着的具体实体，对象是由类创建；
一个类可以创建多个对象。

10、构造方法（构造器）
是一种特殊的方法，方法名必须与类名相同，并且没有返回值，连void都不用
[访问修饰符]类名(参数列表){

}
构造方法不能主动调用，在创建对象时由JVM调用，一般用public。
每个类都至少有一个构造方法。
在没有定义构造的情况下，类会自动产生一个无参数的默认构造方法。
显示化定义构造方法，默认的构造方法失效。
创建对象时必须执行构造方法，而且只能执行一次。
构造方法执行失败，对象创建失败。
一般在构造方法中给属性赋初始值

11、static
  1.1 static修饰属性（变量）
     在变量的数据类型前加上static关键字，可将其声明为静态成员属性。
静态成员属性在内存中只有一份，即该类所有对象共享。
     静态成员变量的作用域只在类内部，但是成名周期贯穿整个程序。
访问方式：类名.属性名
 
  1.2 static修饰方法
     在方法之前加上static关键字，将其声明为静态方法
静态方法只能对类的静态成员属性进行操作
静态方法中不能使用this引用（this表示当前对象的引用，static不属于具体哪个对象，相互矛盾）
 总结：static用在类的成员（属性和方法）上面
 1）在内存上只有一份拷贝，所有对象共享
 2）静态方法中只能操作静态成员属性
 3）静态方法中不能使用this
 4）通过类名.静态成员(方法或属性)访问
 5）静态成员属性一般尽量先初始化。
 6）静态成员的访问也受访问修饰符的约束。
 
  1.3 static修饰代码块
     static{
  //类加载时就被执行
}
一般用做数据初始化
也遵循静态块只能访问静态变量的原则。

12、重载

   1）方法名相同
   2）参数不同（个数不同、类型不同、顺序不同）
   3）同一作用域（同一个类中）
   与返回值无关

13、继承中构造方法的处理：
   1）构造方法不能被继承
   2）父类如果只有默认的或者显示化无参数的构造方法，则在
      子类构造方法中无须显示化调用，由编译器调用。
   3）父类中有显示化有参数构造方法，则子类构造方法中必须
      调用父类的构造方法。
 
总结： 在子类的构造方法中，一定要在第一行调用父类的构造方法，
        如果父类还有更上级的父类，则一定也是先调用更上级父类的构造方法。

   4）父类的构造方法只负责初始化它的属性，而子类的构造方法
     只考虑自己的属性。
   5）java中的继承是单继承

14、super
表示父类对象的引用
  用法一：子类构造方法中调用父类的构造方法
        super(参数列表)。
  用法二：当父类和子类有相同的成员(属性和方法)时
        用super.成员名来表示父类中的。

15、this
在构造方法中调用另外一个构造方法。
    参数名与成员属性名相同时用this.属性名来表示当前成员属性。

16、类成员的访问修饰符
  public：公开的，外部所有类都能访问的到
  protected：受保护的，同一个包或者父子关系可以访问的到
  默认(缺省)的：同一个包中可以访问
  private：私有的，只有本类中才可以访问的到

17、final
   表示最终的，不能修改的，可以修饰变量、方法、类
  1）当final修饰变量后，这个变量就是常量，不能被修饰
     a)修饰基本数据类型： 静态变量使用前必须赋初始值
         在声明时赋初始值，或者在构造方法中赋初始值。  
     b)修饰对象类型：
   不能更改所指向的对象引用，但是可以更改对象中的属性值
  2）final修饰方法
      代表方法不能被更改，即不能被子类重写
  3）final修饰类
     代表类不能被更改，即类不能被继承（String类）
 
18、重写（覆盖）
  有继承，子类的方法原型（方法名、返回值、修饰符、参数、异常）
  与父类保持一致。
  注意：
  1）子类重写的方法修饰符不能低于父类的。
  2）静态方法和final修饰的方法不能被重写。

19、方法重写与重载比较
  不同点：重写必须要有继承，且要求子类与父类的方法原型保持一致。
          方法重载继承不必须，只要求方法名相同，参数列表则要求不同，
 同一作用域（同一个类中）。
  相同点：都是多态的体现形式，都要求方法名相同
  
20、引用转型
   所有的Student都是Person  ok
   所有的Person都是Student  不安全  error
 
    向上转型
    父类 obj = new 子类(); // 多态中的转型都是向上转型
向下转型 
         子类 obj = new 父类();  //不安全的
   
     相同的对象名调用相同的方法，呈现不同的结果，这就是多态。


向上转型总结：
  1）如果子类重写了父类的方法，父类引用调用此方法时，是调用的子类的
  2）如果子类存在而父类不存在的方法，父类的引用不能进行调用
  3）如果父类存在而子类不存在的方法，父类的引用可以进行调用
  
  父类引用调用重写方法。
  
21、多态
  静态多态：
     也叫编译时多态，编译的时候就确定调用哪个方法，一般是指重载
与继承没有必然关系。
一般认为只要有重载，就构造了静态多态。
  动态多态：
    条件：继承、重写、向上引用转型
 也叫运行时多态，在代码运行的时候才确定调用哪个方法

22、抽象类
  
  父类无法提供具体实现的方法，那么这个方法可以声明为抽象方法。
  语法：
     修饰符 abstract 访问类型  方法名(参数);
  如有一个类中有抽象方法，那么这个类必须声明为抽象类。
  语法：
      修饰符 abstract class 类名{
 
 }
 抽象方法必须在抽象类中，抽象类中不一定要有抽象方法。
 
  1）抽象类中可以有普通方法（构造方法也可以）和成员属性。
  2）抽象类不能被实例化，只能被继承。
  3）抽象类的子类应该实现抽象类的所有抽象方法，如果不能全部实现，则子类也是抽象类。
  4）抽象类中构造方法，一般被子类的构造方法调用。
  5）其实抽象类就是强制要求子类实现抽象方法。

23、接口：

   如果某个类中所有方法都是抽象方法，那么可以考虑将其声明为接口
   语法：
      public interface 接口名{
    属性 // 访问权限都是public static final（可省略），是常量
方法  //abstract省略，方法都是public（可省略）
 }
   
24、接口与抽象类
   抽象类：
   1）不可以实例化，只能被继承
   2）用abstract修饰，可以包含非抽象方法
   3）抽象类的子类必须实现其所有抽象方法，如果没有全部实现，则子类也是抽象类
   4）实现多态：抽象类的引用指向子类对象
   接口：
   1）用interface声明，不能被实例化，只能被实现
   2）接口中所有的方法都是抽象方法，不能包含非抽象方法
   3）接口中的属性都是常量，属性方法都是public修饰的
   4）接口可以多继承
   5）接口可以多实现
   6）实现多态：接口的引用指向实现类的对象

25、异常
   程序中可能出现的错误，异常（空指针、栈溢出、数组越界、
   除数0、数字转换异常、文件不存在）
     String  s = "123";
int number = Integer.parseInt(s);
    Error类：常发生JVM中，表示不能恢复的验证错误
Exception类：程序相关的

常用方法
    getMessage()
printStackTrace()

非受查异常(unchecked)：Error类、runtimeException类以及他们的子类，可以不处理

受查异常(checked):必须处理
1、处理异常
   在异常发生的方法内通过try-catch进行捕捉和处理
     try{
   可能发生异常的代码块
}catch(异常类型){
   异常处理
}
1.1）finally关键字：无论是否发生异常，一定会执行，“善后”工作
   应用场景：
      打开文件操作后出现了异常，需要关闭
 建立一个网络连接后出现了异常，需要关闭连接
 数据库资源释放问题
 try{
   打开文件
处理内容  // 异常
关闭文件
 }catch(){
    异常处理
 }finally{
   if(文件未关闭)
     关闭文件
 }
   1.2）多重catch
      异常类层次越低的，越往上写，不论有多少个catch块，最多只会执行其中的一个
   1.3）嵌套catch
2、抛出异常（方法中不处理，交由调用者处理）
    2.1 throw：方法中抛出具体的异常对象


throw抛出异常对象后，捕获程序的流程立即停止，转而寻找异常处理者

处理方式：
1）try-catch
2）throws关键字：方法头声明异常，表示该方法中有异常产生，但是没有处理 

        方法修饰符 返回值  方法名(参数) throws 异常类型（可以多个，用逗号分隔）{
  
  }
  此种方式，如果调用者不处理，则异常继续向上抛，直到有方法处理
3、自定义异常
    继承Exception

26、throw和throws的区别


throw：（针对对象的做法）
抛出一个具体的异常类型，需要用户自己捕获相关异常，
而后再对其进行相关包装，最后再将包装后的异常信息抛出

throws：（针对一个方法抛出的异常）
声明一个方法可能抛出的所有异常信息，通常不用显示的捕获异常，
可由系统自动将所有捕获的异常信息抛给上级方法


throw与throws的总结
1）throw语句是用来明确抛出一个异常对象，throw new 异常();
   throws语句用来声明一个方法可能抛出的异常类型 方法头  throws 异常
2) throws语句实际上是将异常抛给调用者，如果调用者不处理，则继续向上抛，直到
   有调用者处理或者最终由JVM处理
3）throw用在方法内部的，throws用在方法头部
4）throw、throws都是消极异常处理方式，积极的处理方式应该是try-catch处理。
5）throw、throws抛出的异常实际上是受查异常（非Error、非runtime异常），其他
异常可以不处理。

27、内部类
   嵌套类，在类中再去定义一个类,看作是外部类的成员
   class A{
      .....
 class B{
 
 }
....
   }
   1）作为外包类的一个成员，可以访问外包类的所有成员，
      包括static、private修饰的成员属性和方法
 
   2）如果内部类与外包类有相同的属性和方法时，怎样区分？
      外包类同名变量/方法：外包类名.this.变量名/方法
 内部类同名变量/方法：this.变量名/方法
 
   3）内部类的访问修饰符public、缺省、private、protected


   4）static修饰内部类 


   5）内部类在除外包类以外的范围使用
       外包类名.内部类名 对象名 = 外包类对象名.new 内部类名();
 A a = new A();
 A.B b = a.new B();
应用场景：数据连接池、设计模式、算法


28、匿名内部类
   没有名字的类 一般是定义在其他类中，只使用一次，简化代码
   可以用在类(抽象类)、接口上，那么其子类的方法都可以使用匿名内部类来实现。
   多线程
   
   总结：
  1）内部类的类名只能用于定义它的外包类的语句中，并且不能和外包类相同
  2）内部类可以看出是类的成员、可访问外包类变量，包含static、private、final修饰的
  3）内部类的访问修饰符可以是private、protected、缺省的、public的
      而普通类只有public、缺省
  4）只有顶层类可以声明static成员，如果内部类需要定义static的成员，
则应将内部类声明为static，一般的内部类成员不会声明为static。
  5）内部类的创建必须依赖于外包类对象
     A a = new A();   A.B b = a.new B();

29、java.lang.*包
  包装类、Exception、Math类、Object类、String类
  基础包、唯一一个不需要手动导入的包，默认导入的
 
1）包装类：
  继承于Number类
  int (32)        Integer    
  double (64)     Double
  short (16)      Short
  float (32)      Float
  long (64)       Long
  byte (8)        Byte
  char (16)       Character
  boolean (1)     Boolean
  eg :int i=10;
      i.setI
 Object obj = new  Student();
 Integer inte = new Integer(10);

2）基本数据类型转换成包装类型
   方式一：通过包装类的构造方法
   Boolean objB = new Boolean(false);
   方式二：通过包装类的valueOf方法
     //  Boolean objB = (Boolean)false;
3）包装类型转换成基本数据类型
    对象名.XXXValue();

4）包装类对象转换成字符串
    对象名.toString();
5）字符串转成包装类对象
    通过包装类的valueOf方法
6）字符串转换成基本类型（除了Character）
   包装类名.parseXXX()
 
30、什么是自动装箱和拆箱
自动装箱就是Java自动将原始类型值转换成对应的对象，
    比如将int的变量转换成Integer对象，这个过程叫做装箱，
    反之将Integer对象转换成int类型值，这个过程叫做拆箱。
因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。

    原始类型   byte,short,char     ,int    ,long,float,double,boolean
    封装类为   Byte,Short,Character,Integer,Long,Float,Double,Boolean。


31、java.lang包
String类
String s1 = new String("Java is OOP language");
String s2 = "Java is write once,run anywhere";
    s1、s2是String类型的对象
   
   1）字符串中字符的个数（字符串的长度）：length() （数组的长度是length属性）
   2）返回指定索引处的字符：charAt(int i)
   3）字符串的比较
    equals：比较的是字符串的内容（双引号中的数据）是否相等
    ==：比较的是两个字符串对象是否是同一个（比较对象的地址是否相同）
    字符串(常量)池
   4）常用方法：
     搜索字符串： indexOf   lastIndextOf
截取字符串：subString
替换字符串：replace  replaceFrist  replaceAll
更改字符串的大小写：toUperCase  toLowerCase
去掉空格：trim 

String类型的字符串不可更改性、不可继承
  String str3 = "abc";
  str3 = "abcd";//  1、新建一个内容为abcd的String对象
   2、将该对象地址赋给str3
                    3、GC回收"abc"对象；
 一般情况下，如果需要频繁操作字符串，不建议使用String类。


StringBuffer类（线程同步的）
   与String的功能基本一致，但是它的内容是可变的
   StringBuffer sb = StringBuffer("java");   
   append方法：追加内容，操作的是同一个对象
   StringBuffer转成String
   
StringBuilder类（线程不同步的）
   功能几乎与StringBuffer一致
   执行效率上：
      StringBuilder>StringBuffer>String


Math类
  与计算相关的属性和方法
  常量：E  PI
  方法：cos  sin  tan  abs  sqrt  log ......
  四舍五入：    round
  随机数：  random()  产生大于等于0.0 小于1.0


Object类
   equals方法：比较的是地址，与==结果是一致的。
   如果子类没有重写此方法，调用的也是object类中(比较的是地址)
   如果子类重写了此方法，则调用的是子类自己的
   toString方法： 如果子类没有重写，则输出对象当前运行时的地址
   重写了可自定义输出字符串
   
Class类

32、java.util.包
内置的工具包 Random类、日期、日历、集合
Date类（日期类）
某个瞬间的时间对象
   常用：
    Date d = new Date();
   格式化日期：
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = sdf.format(d);
Calendar类（日历类）
    操作日期和时间对象，并且有丰富检索年月日周的方法 
   抽象类,不能直接实例化，但是可以通过以下方法得到对象
    Calendar cal = Calendar.getIntance();
Calendar类与Date类的区别：
  官方不再推荐使用Date，不利于国际化，推荐用Calendar类
  Date表示特定的瞬间，精确到毫秒
  Calendar是个抽象类，操作日历字段（获取下星期的日期）提供一系列的方法

33、java.util中集合框架
  集合：类似于数组，数组的缺点：长度受限制（一经声明，无法修改）
        只能存放相同类型元素
        集合的长度没有限制，可以存放任意类型的元素
List接口及其实现类
   有序，存储顺序与元素添加顺序一致  
   常用方法：
     add()
get()
set()
remove()
size()
clear()
isEmpty()
contains()
ArrayList
   有序、允许重复元素，采用的是顺序表形式实现的
   适用访问、遍历，性能较高
LinkedList
   方法与ArrayList几乎一致，采用的是链表形式实现的
   适用删除、添加元素，性能较高
   
   
Vector
  java5不推荐使用，与ArrayList一样都是顺序表实现的
  1）线程同步的，效率较低，ArrayList是不同步，java5之后对于同步
  问题有集中的处理策略
  2）数据增长型问题，当需要扩充容量时，ArrayList是增长原来的一半，
  但Vector是增长原来的一倍
 ArrayList  10  15  23
 Vecotr     10  20  40        10000 20000


 
Set接口及其子类
    无序、不允许重复
  HashSet：哈希码实现
  TreeSet：树的数据结构实现，与HashSet基本是一致的，
  但是它可以确保集合中元素保持有序，但是泛型类必须实现Comparable接口
  
Iterator
 迭代器是一种设计模式，它可以遍历并选择对象。
 只要实现了Iterator接口的类，都可以通过迭代器遍历。
   hasNext():检测是否还有元素
   next():返回下一个元素
   
Map接口及其子类
   采用键值对存储元素
   key - value  key不能重复，value可以重复
   001  杨亮    
   002  王涛
   003  向荣
   004  杨亮
   005  王涛
   Map中一对键值对看成一个整体对象，叫做Entry，它是定义在
   Map接口中的
   HashMap
   TreeMap
   
34、集合中元素排序（合并算法）
步骤1：元素类实现Comparable接口，实现compareTo方法
步骤2：采用Collections.sort()对集合进行排序



 


有序否 允许元素重复否
Collection                                  否  是


List           是  是 


AbstractSet  否  否
Set           HashSet  否  否


TreeSet  是（用二叉树排序）  否




AbstractMap  否 使用key-value来映射
Map HashMap  否 和存储数据，
Key必须惟一 ，
TreeMap  是（用二叉树排序）   value可以重复