中软Java学习第六天笔记

堆和栈的总结：
    基本类型-----1、内存空间大小固定          2. 生命期固定   （局部变量，超过变量作用域就回收）
    引用类型-----2. 内存空间的大小不固定      3. 生命期不固定（引用计数）


int[] ages = new int[5];      -----内存分配在堆内
                            //只要看到new，内存就一定分配在堆内

 public static void main(String[] argv) {
        // 静态初始化数组
        String[] names = { "Michael", "Orson", "Andrew" };
        // 动态初始化数组
        String[] animal = new String[4];
     
        names = animal;                //这是引用地址的赋值
        
        System.out.println(names.length);
        System.out.println(animal.length);
    }


    String str = "abc";
     等效于：
     char data[] = {'a', 'b', 'c'};
     String str = new String(data);


   //  输出结果为true,"abc"是一块常量数据，会存于常量池中
        String aa = "abc";
        String bb = "abc";
        if(aa == bb ){
            System.out.println("true");
        }else{
            System.out.println("false");
        }


       private final char[]   value;                     //String中的所有字符串内容，都存储在String的value属性中



  //在类的内部，同类型的对象引用，可以调用类内的private属性信息
 public String(String original) {
    int size = original.count;
    char[] originalValue = original.value;
 }

  String bb = new String("abc");         //分配了两块内存

  String cc = "a" + "b" + "c";           //分配了5块内存

//两个重要的构造函数
  String(char[] value)
          分配一个新的 String，使其表示字符数组参数中当前包含的字符序列
   String(String original)
          初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本


//重要方法
   int indexOf(String str)
          返回指定字符在此字符串中第一次出现处的索引


        int index = url.indexOf("8081");
        System.out.println("index=" + index);
        
        String sub = url.substring(index);
        System.out.println(sub);

    String[] split(String regex)

 String cookie = "uname=sssss,pwd=abc";
        String[] upwd = cookie.split(",");
        for(int i=0;i<upwd.length;i++){
            System.out.println(upwd[i]);
            
        }



//字符串转换成整数的方式
       String aa = "102";
        Integer bb = new Integer(aa);
        Integer cc = Integer.parseInt(aa);
        Integer dd = Integer.valueOf(aa);        
        System.out.println("dd=" + dd);

//把整形转换为字符串
     String kk = String.valueOf(bb);

      //字符串转换成日期
    String aa = "2016-10-13";
        String bb = "08/23/2016";
        SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat s2 = new SimpleDateFormat("MM/dd/yyyy");
        try {
            Date d1 = s1.parse(aa);
            Date d2 = s2.parse(bb);    
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        
        //日期转字符
        Date today = new Date();
        SimpleDateFormat s3 = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
        String pp = s3.format(today);
        System.out.println(pp);






泛化  generalization    ---- 抽象（从特殊--->>一般）


类之间的关系：
    is-a    generalization    ： 继承的关系
    has-a   aggregation       :  聚合关系     例如：  学生类中有一个班级的属性，表示了学生所属的班级 （成员变量级的相识关系）                  
            dependency       :   依赖的关系   例如： 如Dog来参加游泳比赛                              （方法级的相识关系）



String 与 StringBuilder、StringBuffer三者的区别：
    String代表字符串常量，一旦分配内存后，不能修改
    StringBuilder、StringBuffer都是可变字符序列

StringBuffer是线程安全的可变字符序列
StringBuilder是线程不安全的可变字符序列 ------开发时首选StringBuilder，因为它的速度快
                                   参考ArrayList与Vector的对比



面向接口编程：
    接口代表的是一种能力；
    通过接口作为方法的参数，来约束这个方法可以做什么事情；
    一个类实现了哪些接口，就表明这个Class具有哪些能力；      public abstract class Pet implements ISwim{}

接口的特点：
    接口中只能定义抽象方法和常量；
    接口中只能使用public，不能使用private和protected    


public interface ISwim
{
    public abstract void swim(Pool pool);
    public static final int age = 10;
}

//接口与抽象类的对比
    1. 接口是能力的表示
       抽象类是Class，它有属性和行为

    2. 接口里可以定义常量，但是没有属性

    3. 接口中的方法，都是public abstract （共有的抽象方法，不能定义其它类型的方法）

    4. 抽象类中的方法，可以是抽象的，也可以是非抽象的。但是接口中必须是抽象的；


多态：   继承、重写、父类的引用+子类的对象
       
         实现、重写、 接口+子类的实现

面向接口编程，本质仍然是多态