core java整理2.0

IDE:Integrated
9.30 java语言基础(one day
  1.命令提示符：d:、cd c:work 、dir、path、等
  2.最好在当前目录运行这个类，否则需要以下形式执行：
  java -cp 类所在的目录 类名
  3.注释:单行、多行、文档
  //、
   /*
   */、
  /**
  *
  */
  4.输入、出(Scanner类）
  import java.util.Scanner;
  Scanner scanner=new Scanner(System.in);
  int a=scanner.nextInt();
  int b=scanner.nextInt(2);//二进制
  String str=scanner.next();
  nextLine()/nextByte()/ nextShort()/ nextDouble()/
  
  hasNextInt();
  hasNextInt(2);//按照指定的进制判断
  
  eg.//两者结合使用，先判断是否合法，再执行，这样比较安全
  while(scanner.hasNextInt()){
   sum+=scanner.nextInt();
  }
  
  print()/ println()/ printf();
  eg.
  int a=10;
  int b=20;
  int c=a+b;
  System.out.printf("%d+%d=%d",a,b,c);//输出格式化消息
  格式化规定符：http://blog.csdn.net/feiniaolql/article/details/7177783
  
  5. 标识符 、关键字、 字面值
  标识符使用Unicode字符集
  Unicode(2^7)前128个字符与ASCII码一致（2^16）
  int 数字1=10；//合法，不提倡
  命名习惯
  
  关键字不能作为标识符
  eg. abstract/ for / int
  
  字面值
  eg. null字面值
  boolean：true/false
  
  变量：
  局部变量：系统不会自动对其进行默认初始化
  合法命名的条件：
  满足标识符的命名要求；不能使关键字，也不能是true、null等特殊意义的字面值；在同一个作用域内不能重名
  
  6.八种数据类型
  整数类型：byte / short / int / long
  浮点类型：float / double
  字符类型：char
  逻辑类型：boolean
  eg.float b=1.1;//错误
  char c=97;//c表示字符‘a'
  
  转换：
  byte>short> int > long > float> double
        char>    
   强制转换：
   int a=10;
   char c=(char)a;
   隐含强制转换：eg.  byte b=12; 但byte b; int a=12;a=b;//出错，这种隐含转换仅用于字面值对变量进行赋值时
  7.数组
   arraycopy
  8.算数运算符
  精度：其结果类型是两个参与运算操作数的精度较高者，且最少是int类型
  
  移位运算符：<< 有符号左移 、 <<<无符号
  1<<31; //-2^31
  -1<<<1; //2^31-1
  移位运算结果的数据类型：
  byte a=10;
  a=a>>1; //错
  a=(byte)a>>1; //自动转换成int
  
  位运算符：& 、| 、 ^ 、~
  
  赋值运算符： x=1; x+=1;
  
  关系运算符： <  >=
  
  逻辑运算符：&&  ||   !   ^
  
  其他运算符：？ 条件运算；
     new  创建对象
     . 用于访问对象或类的成员方法、变量
     []用于数组操作
     instanceof 判断对象时什么类型
  9.语句
  分支：if 和 switch-case
  switch-case: 一般为char  byte  short  int / Character  Byte  Short  Integer  enum
  循环：for  、 while 、 do-while
  控制：break 、 continue 、return

(9.30)
 类与对象基础
  1.Math类
  
  2.String 、 StringBuffer 、StringBuilder
   区别： String 字符串常量（不变模式，对象池）
     StringBuffer 字符串变量（线程安全）
     StringBuilder 字符串变量（非线程安全）
  String:
   1)常用构造器
    public String(char[]value)
    public String (char[]value,int offset,int count )
    publci String (String original)
   2)常用方法
    A.
    public int length()
    pulbic char charAt(int index)
    public char[] toCharArray()
    B.查找单个字符
    public int indexOf(int ch)
    public int indexOf(int ch,int fromIndex)
    public int lastIndexOf(int ch)
    public int lastIndexOf(int ch,fromIndex)
    C.字符串内容比较
    public boolean equals(Object anObject)
    pulbic boolean equalsIgnoreCase(String anotherString)
    public int compareTo(String anotherString)
    public int compareToIgnoreCase(String anotherString)
    public boolean startsWith(String prefix)
    public boolean startsWith(String prefix,toffset)
    D.搜索字符串
    public int indexOf(String str)
    public int indexOf(String str,int fromIndex);
    lastIndexOf()
    E.获取子字符串
    public String substring(int beginIndex)
    public String substring(int beginIndex,int endIndex)
    F.创建新字符串
    public String replace(char oldChar,char newChar)
    replaceAll(String regex,String replacement)
    replaceFirst(String regex,String replacement)
    toLowerCase();
    toUpperCase()
    concat(String str)
    trim()
    G.拆分字符串
    public String[] split(String regex)
    split(String regex,int limit)
    
  StringBuffer
   public StringBuffer()
   public StringBuffer(Stirng str)
   pulbic StringBUffer(int capacity)
   
   public int capacity()
   length()
   toString()
   常用方法：
    A.添加方法
    append();
    B.插入方法
    insert(int offset,插入内容（如：boolean b,char c,String str...）)
    C.删除、替换、修改方法
    delete(int start,int end)
    deleteCharAt(int index)
    replace(int start,int end,String str)
    reverse()
    setCharAt(int index,char ch)
    setLength(int newLength)
    D.查找
    indexOf
    lastIndexOf
    E.读取
    substring
    charAt
    getChars
    
  StringBuilder：与StringBuilder一样
 
  如何选择三者：
    ●  如果你偶尔对简单的字符串常量进行拼接，那么可以使用String，它足够简单而且轻量级； 
    ●  如果你需要经常进行字符串的拼接、累加操作，请使用StringBuffer或StringBuilder；
    ●  如果是在单线程的环境中，建议使用StringBuilder，它要比StringBuffer快；如果是在多线程的环境中，建议使用StringBuffer，它是线程安全的；
（10.2补充）{
   两种创建字符串的方法：
    String name="haha";//从对象池中得到,如果没有则创建
    String name=new String("haha");//创建新的“haha”。。。。创建了两个对象，首先在对象池创建“haha”,再作为参数创建对象
    
    Integer i=5; //包装类Integer也有不变模式和对象池，与String类似（day06 am）,但为什么没有StringBuffer的，所以要是经常改变Integer的话，就不用了呗，改为int,因为它可以随便改变的。
    Integer i=new Integer(5);
   } 
  3.数组类
   A.一维数组的拷贝：System.arraycopy()
   public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
   eg.System.arraycopy(arraySrc,3,arrayDest,1,2);
   B.   排序与搜索：Arrays.sort() ;Arrays.binarySearch()
   public static void sort(类型[]a);
   publci static void sort(类型[]a,int fromIndex,int toIndex);
   public static int binarySearch(类型[]a,类型key);
   C.不等长的二维数组
    首先通过"new 数据类型[行长度][]"创建二维数组，再分别创建相应长度的数组
    eg. int[][] table=new int[2][];
     table[0]=new int[2];
     table[1]=new int[4];
  4.基本类型包装类
   Integer:public static int parseInt(String s)
     public static int parseInt(String s,int radix)
     public static String toString(int i,int radix)
     public Integer(int value)
     publci Integer(String s)
     public static Integer valueOf(int i)
     public static Integer valueOf(String s,int radix)
     publci static Integer decode(String nm)
     public byte byteValue()//shortValue(),intValue(),doubleValue()
     
10.1 5.BigInteger与大数处理
   BigInteger:处理大整数
    在具体应用中如果某个整数的取值范围超过long类型时，为了避免运算溢出等情况，需要考虑BigInteger或浮点型.
    浮点型：精度损失，速度较快
    BigInteger:不会损失精度，速度较慢
     eg. BinInteger result=BigInteger.ONE;
     for(int i=1;i<n;i++){
      BigInteger k=BigInteger.valueOf(i);
      result=result.multiply(k);
     }
   BigDecimal:处理大小数
   
  6.时间处理
   A.Date类
    读取和设置毫秒数
    转换为字符串
    Date对象的比较
    
   B.SimpleDateFormat类：public String format(Date date)
    eg.  Date dateNow=new Date()
      SimpleDateFormat dateForm=new SimpleDateFormat(yy年mm月dd日）；
      dateForm.format(dateNow);
   C.Calendar:  Calendar calendar=Calendar.getInstance();
    获取日历字段的值：public int get(int field);
   D。Date对象与Calendar对象之间的转化： calendar.setTime(dateNow);//将calendar时间设置为dateNow的时间
    
  7.Exception与异常处理  
   运行时异常和非运行时异常
（10.2补充）{
  8.Object类 
  equals(Object obj):（覆盖的掌握，及其要对其覆盖必遵循的五大原则）
       反身性；对称性；传递性；一致性；非空性
   String s1=new String("hello");
   String s2=new String("hello");
   sysou(s1==s2);   //false
   sysou(s1.equals(s2)); //true   此处不是Object的equals方法，是String.。比较的是值
  hashcode：1）如果成员变量时引用类型，可以调用它的hashCode方法获得它的哈希码
      2）如果某个成员变量时基本类型，先创建基本类型的包转类，再
      3）如果存在多个成员变量，进行异或等位运算（或算数运算）
  toString
  9.int , Integer , String之间的转换
   int转Integer:  Integer i=5;//自动装箱和拆箱  JDK5.0
        new Integer(5);
        Integer.valueOf(5);
   Integer装int:  i.intValue();
        int a=new Integer(5);//  JDK5.0
   String转Integer: new Integer("12");
        Integer.valueOf("12");
   Integer转String: .toString()
   String转int:  Integer.parseInt("");
   int转String:  Integer.toString(5);//(5,int 进制)
  10.包装类：为什么包装类；提供了什么方法；类型转化
  11.main方法的参数
  }
  面向对象：以数据抽象为导向
  面向过程：以业务逻辑为导向（C中没有类，只有函数）
  
  生成对象的过程：分配对象空间；
      给属性附初值；
      调用构造方法
 类的设计与封装
  封装：类、方法、包都可认为封装
     类的封装：i.该私有的私有，该公开的公开
     ii. 类的属性一般为私有，
     iii.get和set方法（只读和只写），可以在set方法里的参数设置安全检查。其实就叫JavaBean（良好封装的组件）
  继承：继承是多态的基础（extends 扩展；inherit继承）
    里氏代换原则
    super()  this()  super.xxx   this.xxx的用法
    子类中一般不再定义相同的属性，没意义
    覆盖的注意点
    强制类型转换一般和instanceof连用
     eg. if(a1 instanceof Bird){
      Bird b=(Bird)a1;
     }
    Animal a=new Bird();
    a.move();//子类的move
    a.name;//父类的name(父子类都有name的条件下，不提倡这样)
    
  多态
 类继承与接口的设计(one day
    接口没有构造方法
    接口---继承（多）--接口
    接口中的属性必须赋值
    接口编程的 好处：
     尽量降低系统的 耦合度；
     将标准制定者和标准的实现者分离
     接口应该尽量简单和单一
     基于接口的编程（基于抽象的编程）
     
（10.2补充）{
  实例初始器：
    特点：  在构造器代码之前运行，并在对域赋初始值之后
      调用构造器创建对象时，会首先调用实例初始器来完成部分对象初始化工作
      无论使用哪个构造器调用对象，实例初始器代码都要执行
    作用：  在构造器中的代码执行之前，先进行对象数据的某些初始化工作
      如果存在多个构造器，那么可以将构造器的部分公共代码抽取到实例初始器，实现对象创建的公共初始化操作
      
  静态初始器：
    特点：  类加载时仅静态初始化一次
      在声明类变量时，可以通过某个表达式设定它的初始值，或者在静态初始器中对它进行初始化。注意：声明类变量时的赋初始值操作总是首先运行，然后再执行静态初始器
  
  设计子类的构造器：
    思路：  通过super调用超类的构造器，进行超类成员变量的初始化
      通过继承得到的超类方法，进行超类成员变量的初始化
  
  类方法隐藏和实例方法覆盖的效果区别：
    类方法隐藏：虽然子类重定义了超类继承的类方法，但是新方法不会影响到超类方法对他的调用
    实例方法覆盖：在子类中重定义继承的实例方法之后，超类中对该方法的调用都替换成新定义的方法
  
  super的用途：调用直接超类的构造器；访问从超类继承的成员
  
  禁止声明静态的抽象方法
  抽象方法和类的设计意图：
    强迫子类实现超类的抽象方法
    确保子类采用统一的方法调用格式
  
  上转型：无法通过上转型对象访问子类新增的方法和域；通过上转型对象可以访问被子类覆盖的实例方法，除此之外，都访问超类定义的方法和域
  下转型：一般要先通过instanceof运算符判断将要转型引用是否是指定类型的对象，从而避免出现非法的向下转型
(10.3补充）{
重点： 超类的设计理念：
    提供子类通用的功能代码
    促进基于上转型对象的管理开发
    （如何增强上转型对象的功能：
      上转型对象能够直接访问的成员必须在超类中声明
      如果子类覆盖了某个实例方法，那么上转型对象将调用子类的实例方法
      不能直接访问子类声明的其他成员，但这些成员可被覆盖的实例方法间接访问
  超类中抽象方法的设计意图：
    基本设计意图：见上；
    重要设计意图：满足上转型对象的功能访问需求。
         1）抽象方法本身就是上转型对象需要调用的功能
         2）基于抽象方法，抽象可以设计更多功能的方法，从而丰富上转型对象的功能
重点： 使用接口回调技术：  
}   
}  
10.2 集合框架与泛型(one day
（10.3改）{
   z在管理一组对象时，尤其是管理数量可变的一组对象时，应该优先选用集合类而不是对象数组
   
  泛型：作用：提供编译时的类型安全检查，同时减少类型强制转换
     注意：对于某个泛型类或接口G<E>以及两个类型A和B，那么即使B是A的超类型，也不能将G<A>转换成G<B>,一般保持泛型参数一致，通配符类型除外
  通配符：<?> , <? extends A> , <? super A>
  Collection<E>:增删查，将集合转换成数组等方法
  Iterator<E>:
     Iterator iterator=c.iterator();
     while(iterator.hasNext()){
     Sysou(iterator.next());
     }
     (
     补充：  for（int i=....）{}    List中可以使用此种遍历；
       for(Object obj:list){} 原理与迭代一样，只要能够使用.iterator()就可以用此种方法
     )
     remove()；//的使用
    ListIterator<E>:previous , next
  List<E>:特点：可以存储重复的元素，可以基于位置操作集合
     实现类：LinkedList<E>,ArrayList<E>
     1).链表特点：方便地进行元素的增加、删除。即元素个数变化的代价较小，但查询性能比数组差
     2).数组特点：查询性能比链表好，但缺点是长度不可变化，删除代价大
     
  Set<E>:重写equals(Object obj),hashCode(), toString()  
  
  Collection<E>接口 > List<E>接口   (实现类:Vector(是一个线程安全的ArrayList),LinkedList<E>和ArrayList<E>)
        > Set<E> 接口   (实现类：HashSet<E>(必须覆盖hashCode和equals方法),TreeSet<E>, LinkedHash<E>)  > SortedSet<E>接口(实现类：TreeSet<E>(存储同类型，可比较大小的。))
        > Queue<E>接口  (实现类：LinkedList<E>, Deque<E>)
       
  Iterator<E> 接口  > ListIterator<E>接口
  
  Map<K,V>    接口  > sortedMap<E>接口  (实现类：HashMap<K,V>, TreeMap<K,V>, LinkedHashMap<K,V>)
  
  Comparable<T>接口的compareTo方法
  Comparator<T>接口与对象比较器：compare方法
  掌握集合的4点：
   怎么选择集合对象；
   怎么添加集合元素；
   怎么删除集合元素；
   怎么循环，遍历每一个元素。
   
  HashSet的处理规则：首先得到对象的哈希码(hs.add(obj);obj.hashCode()),然后hashCode运算，得到要存储的下标位置，再判断是否冲突(),如果不冲突就直接加进去，如果冲突再做判断（equals）,如果equals为真，则不加入，否则找某个位置加入
  HashSet<E>不允许重复与TreeSet<E>不允许重复情况是不一样的。TreeSet<E>是compareTo为0时不允许加入。
  eg.public int compareTo(Object obj){//比较的规则可以自己定义
   Student stu=(Student)obj;
   if(this.age==obj.age){
    return this.name.compareTo(stu.name);
   }else{
    return this.age-stu.age;
   }
   }
   Java.lang:                 
     Iterable                   
     Comparable
   Java.util:
     Iterator
                 Comparator
}