java笔记

抽象类和接口的区别：
A：成员区别
抽象类：
成员变量：可以变量，也可以常量，
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B：关系区别
类与类
继承，单继承
类与接口：
实现，单实现，多实现
接口与接口：
继承，单继承，多继承
C：设计理念的区别：
抽象类 被继承体现的是：is a 的关系。抽象类中定义的是该继承体系的共性功能。
接口：被实现的体现的是：like a的关系。接口中定义的是该继承体系的扩展功能。

2: 异常处理

异常处理

案例一：
package cn.itcast_04;

public class Ecample20 {

    /** catch代码块中加入return语句可以结束当前方法，此时程序就不会往下进行了，
     *  但是finally里面的代码块依旧会执行，并不会被return语句影响，
     *  也就是说不论程序是否发生异常还是使用return语句结束，finally中的语句都回执行
     *  正是由于这种特殊性，在程序设计的时候，经常会在try……catch后使用finally
     *  代码块来完成必须做的事情，例如释放系统资源
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try{
            int result = divide(4,0);
            System.out.println(result);
        }catch(Exception e){
            System.out.println("捕获的异常信息为:"+e.getMessage());
            return;
        }//如果我们希望有些语句无论是否发生一场都要执行，就可以加入finally代码块里面
        finally{
            System.out.println("进入finally代码块");
        }
        System.out.println("程序继续往下执行");
    }
    public static int divide(int x, int y){
        return x/y;
    }

}
案例二：
public class Example21 {

    
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        System.out.println(divide(4,2));
    }
    public static int divide(int x, int y) throws Exception{
        int result = x/y;
        return result;
    }

}
案例三：
自定义异常
package cn.itcast_04;

public class DivideByMinusException extends Exception {
    public DivideByMinusException(){
        super();
    }
    public DivideByMinusException(String message){
        super(message);
    }
}
package cn.itcast_04;

public class Example21 {

    
    public static void main(String[] args) throws Exception{
        try{
            System.out.println(divide(4,-2));
        }catch(DivideByMinusException e){
            System.out.println(e.getMessage());
        }
    }
    public static int divide(int x, int y)throws DivideByMinusException{
        if(y < 0){
            throw new DivideByMinusException("被除数是负数");
        }
        return x/y;
    }
}

没有构造方法，那就是静态的类
Arrays：针对数组进行操作的工具类，比如说排序和查找

对象数组：
package cn.itcast_02;

public class StudentTest {

    /**
     * @param args
     * @throws CloneNotSupportedException 
     */
    public static void main(String[] args) throws CloneNotSupportedException {
        Student[] students = new Student[5];
        students[0] = new Student("明明", 20);
        students[1] = new Student("丽媛",19);
        students[2] = new Student("迪迪",19);
        students[3] = new Student("倩倩", 18);
        students[4] = new Student("彭辉", 19);
        for(int x = 0; x <students.length; x++){
            System.out.println(students[x].getName()
                      +"---"+students[x].getAge());
        }
    }

}

Collection功能的概述
1：添加功能
    boolean add(Object obj): 添加一个元素
    boolean addAll(Collection c): 添加一个集合的元素。
2:删除功能
    void clear() : 移除所有元素
    boolean remove(Object o): 移除一个元素
    boolean removeAll(Collection c): 移除一个集合的元素
3:判断功能
    boolean contains(Object o):判断集合中是否包含指定元素
    boolean containsAll(Collection c): 判断集合中是否包含指定集合的元素
    boolean isEmpty();判断集合是否为空
4:获取功能能
    Iterator<E> iterator()(重点)
5：长度功能
    int size():元素的个数
    数组中没有length方法，字符串有length方法，集合没有length方法，求集合长度用的size
6：交集功能
    boolean retainAll(Collection c)
7:把集合转换为数组
    Object[] to Array();


数组和集合区别：
    1：数组长度固定，集合长度可变
    2：内容不同，数组存储的是同一类型的元素，而集合可以存储不同类型的元素。
    3：元素的数据类型问题：
        数组可以存储基本类型，也可以存储引用类型，但是集合智能存储引用类型。集合智能存储对象。
集合类特点：
    集合只能用来存储对象，集合长度可变，集合可以用来存储不同类型的对象。

因为存储多个元素我们也是有不同需求的：比如说，我们要这多个元素中不能有相同的元素，
再比如说我要这多个元素按照某种规则排序一下。针对不同需求，java就提供了不同的集合类。这多个集合类的数据结构不同。
结构不同不重要，重要的是你能够存储东西，并且还要能够使用这些东西。比如说判断获取等。
既然这样，那么这多个集合类是有共性内容的。我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。    

 匿名内部类 

package cn.itcast_04;

public class Example {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        shout(new Animal(){
            public void shout(){
                System.out.println("miao");
            }
        });
    }
    public static void shout(Animal an){
        an.shout();
    }

}

 eclipse等问题

eclipse内容辅助键
    alt+ /用法：
        Alt+/ 提示作用 帮助补齐一些东西，还可以帮助你起名字，
        main+alt+/,syso+alt+/
    alt+shift+s给出一些快捷操作，比如format就是格式化代码，下方的generate就是一些自动转换的方法，
        比如点击变量，就自动生成了toString方法 
    alt+shift+s+o alt+shift+s+c alt+shift+s+r
    alt+shift+s可以提示补全个人写的
eclipse快捷键：  
    1：格式化 ctrl+shift+f
    2：导入包 ctrl+shift+o
        如果该类在一个包中有就直接出来了，
        如果多个包中都有，会弹出一个框框供你选择，不懂就用API去查一下
    3：alt+/ 可以提示你跟多东西
    4：注释：ctrl+/ 
         ctrl+shift+/, strl+shift+
    5:代码上下移动 选中代码 Alt+上下 箭头
    6：查看源码， 选中类名，(F3或者Ctrl+鼠标点击)

Object的常用方法：
    1:public int hashCode()
    返回该对象的哈希码值。支持此方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能。 
    2:public final Class<?> getClass()
    返回此 Object 的运行时类。返回的 Class 对象是由所表示类的 static synchronized 方法锁定的对象。
    注意这个返回值是Class类的一个对象
        1：Class类的其中一个方法名字叫：getName，这个方法是获取相应类的class文件的文件名的方法
        2：toString方法会返回一个“以文本方式表示的”此对象的字符串。结果应该是一个简明易于读懂的表达式。
            换句话说，该方法返回一个字符串，它的值等于：
                getClass().getName() + '@'+Integer.toHexString(hashCode);
            返回一个该对象的字符表示
        3：Integer.toHexString(int i):把一个整数装换成十六进制的字符串

        4：toString, 父类的toString的返回至使没有意义的，
            可以重写toString以返回一些有用的信息，
            也可以不重写，自动生成toString，自动生成的toString包含该对象的成员变量的详细信息
            世界System.out.println(对象名称)的结果也是返回该对象的成员变量的详细信息

            输出对象的时候相当于调用的该对象的toString方法，转换成字符串了
            如果没有重写，该对象名打印出来的还是类名+'@'+ 地址值 

            基本类型比较的时候比较的是值是否相同。
            引用类型比较的时候比较的是地址值是否相同,例如
            Student s1 = new Student();
            Student s2 = new Student();
            System.out.println(s1 == s2);//输出false
            Student s3 = s1;
            System.out.println(s1 == s3);//输出true
        5：public boolean equals(Object obj);指示其他对象是否与此对象“相等”
        这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法，一般比较成员变量是否相同
        例如： 
            public boolean equals(Object obj){
                Student s = (Student)obj;
                if(this.name.equals(s.name) && this.age == obj.age){
                    return true;
                }else {
                    return false;
                }
            }
        
        但是，如果要比较的两个对象本身地址就相同，那就不用比较了，直接返回true，因为那就是同一个对象 
        如果要比较的两个对象属于不同的类呢？
            这个时候必须在equals代码中加上判断两个对象是否是同一个类的代码，如果是就不是同一个类直接返回false    
            如果是同一个类那就继续判断这两个对象是否相同
            用法： 对象名 instanceof 类名 
        @@@重写的代码优化：提高效率，提高程序的健壮性，最终版还是自动生成的
    equals：
        引用类型：默认情况下比较的是地址值
        不过我们可以根据实际情况重写该方法。一般重写都是自动生成，比较对象的成员变量是否相同。

        6: protected void finalize() 当垃圾回收器不存在对该对象的更多引用时，由对象的垃圾回收器调用该方法。
        该方法用于垃圾回收，但是什么时候回收不确定。重写这个方法实现资源的重新配置。

        7:protected Object clone();创建并返回该对象的一个副本。
        Cloneable：此类实现了Coloneable接口，以指示Object.clone()方法可以合法的对该类实例进行案子段复制。
               这个接口是标记接口，是告诉我们事先该接口的类就可以实现对象的复制了。
        a:也就是说将来如果想让该对象被克隆，就必须让要克隆的类实现Clonealbe接口。
        b:克隆的时候要抛出异常
        c:如果要用克隆方法的话，自己写的类一定要重写clone方法，因为clone是用protect修饰的.
        如果不重写，只有Object类的子类，也就是说自己写的那个类里面才能用这个方法。
        

    

学编程最好的技巧有事没事上网上或者论坛上去看一些比较优秀的技术文章，一些比较好的代码！！！！！
你看别人怎么设计这个类的，别人怎么来写这个方法名，别人怎么写返回值的，别人怎么定参数的
看别人写的多了，你慢慢就会些这些东西了

！！！！！！！！！！！！！！！！！！！！！
学习编程要现学现用，除了一些特别基础的东西之外，学完之后立马就用，
有点基础之后，在完成一些比较大的功能的时候，做不出来也正常，
你至少现在去学习要完成它需要学什么，学完之后立马就用，开发的时候很多时候就是这样的
所以编程学到后来难在你不知道你要做什么，其实怎么做很简单，
这个东西，你不会做肯定有人会，你遇到问题，很多年前肯定有人遇到过了
你现在的问题就是你不知道怎么去搜这些东西，一旦你的基础掌握之后，再回头看，你就会觉得这些很简单
所以编程最大的问题不是怎么去实现，而在于你要知道你要做什么，就是需求问题
！！！！！！！！！！！！！！！！！！！！！！

出问题的时候：
1：是不是没有导入包 ctrl+shift+o;
2: 是不是自动加上的代码出的问题

注意删除的时候是只从工作空间删除了还是永久删除了

导入项目到工作空间：
    在项目区域右键找到import
    找到General，展开并找到
    Existing Projects into WorkSpace
    点击next，然后选择你要导入的项目

修改项目问题的时候
    1：不要随意修改项目的名称
    2：如果真的要修改项目的名称，不要忘记配置文件.project中的<name>把这里改为你该后的名称</name>

查看项目所在的路径
    选中-右键-Properties-Resource-Location

导入项目的时候需要注意，项目空间里不可能出现同名的项目

如何去断点：
    找到Debug视图的varables界面，找到breakpoints，并点击，然后看到所有的断点，最后点击双叉号，move all