java入门学习之二

java入门学习之二 （更加详细 请阅附件）
  1.继承、多态、重写？
    继承应该从子类和父类的关系来理解，子类继承父类的方法和属性就是继承，关键字extends。自动转型说的也是子类和父类的关系，指的是子类对象有时候会自动转型为父类类型，这就取决于对象定义前是子类还是父类的类型。但不管怎么样，如果子类重写了父类中的方法，调用的就是子类中的实现，否则就是调用父类中的方法。说到重写，overwrite，应该说就是刚刚那句话，子类和父类中方法的区别，子类可以重写父类中的方法，改变父类的实现。比较重载，我们应该从参数类型和数量不同的方法这个方面来区分，这就很容易理解。多态是指我们遇到的虽然是统一类型的对象，但在具体的调用时，由于继承与重写机制，方法执行的结果不同，或者说，只有到运行时，才知道到底是什么东。

  2.数据类型、值传递和引用传递有什么区别，String是什么传递？

    Java中的数据类型分为两大类：一类是引用类型，也叫类类型，是指通过类创建的对象的变量名字；一类是原始类型，即8大基本类型，这类型的数据在调用传递时尊实“值传递”规则。
    String是Java中的一个类，而不是一种基数据类型，因为它有自己的方法和属性。为什么我们说“特殊的String”呢？String是一个类，String对象肯定就是引用类型，但它却是跟原始类型一样，遵守值传递的规则；这是因为String类在JVM中是被特别设计过的，因为它的用量特别大，为了提高效率，String通过值传递方式来使用。

3.Set如何遍历，有哪些子类、List如何遍历，有哪些子类、Map如何遍历，有哪些子类，Map中是否可以放入null的key或Vlaue？Set,List呢？
      一般用for来遍历，用.length或者.size确定大小，两者最大的区别是list可以无限增加元素，对象，而set一般是固定的，它不保存重复元素。
List的功能方法
    AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector 这些都是它的实现类

　　List(interface): 次序是List最重要的特点；它确保维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(只推荐 LinkedList使用)。一个List可以生成ListIterator，使用它可以从两个方向遍历List，也可以从List中间插入和删除元素。
　　ArrayList: 由数组实现的List。它允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList，而不是用来插入和删除元素，因为这比LinkedList开销要大很多。
　　LinkedList: 对顺序访问进行了优化，向List中间插入与删除得开销不大，随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、 addLast()、getFirst()、getLast()、removeFirst()、removeLast()，这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
Set的功能方法
    AbstractSet, ConcurrentSkipListSet, CopyOnWriteArraySet, EnumSet, HashSet, JobStateReasons, LinkedHashSet, TreeSet 都是它的实现类。
　　Set(interface): 存入Set的每个元素必须是唯一的，因为Set不保存重复元素。加入Set的Object必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。
　　HashSet: 为快速查找而设计的Set。存入HashSet的对象必须定义hashCode()。
　　TreeSet: 保持次序的Set，底层为树结构。使用它可以从Set中提取有序的序列。
　　LinkedHashSet: 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
　　HashSet采用散列函数对元素进行排序，这是专门为快速查询而设计的；TreeSet采用红黑树的数据结构进行排序元素；LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，Set需要维护元素的存储顺序，因此要实现Comparable接口并定义compareTo()方法。

Map----一组成对的“键值对”对象，即其元素是成对的对象，最典型的应用就是数据字典，并且还有其它广泛的应用。另外，Map可以返回其所有键组成的Set和其所有值组成的Collection，或其键值对组成的Set，并且还可以像数组一样扩展多维Map，只要让Map中键值对的每个 “值”是一个Map即可。某些映射实现对可能包含的键和值有所限制。例如，某些实现禁止 null 键和值，另一些则对其键的类型有限制。尝试插入不合格的键或值将抛出一个未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询是否存在不合格的键或值可能抛出异常，或者返回 false；某些实现将表现出前一种行为，而另一些则表现后一种。一般来说，试图对不合格的键或值执行操作且该操作的完成不会导致不合格的元素被插入映射中时，将可能抛出一个异常，也可能操作成功，这取决于实现本身。这样的异常在此接口的规范中标记为“可选”。

AbstractMap, Attributes, AuthProvider, ConcurrentHashMap, ConcurrentSkipListMap, EnumMap, HashMap, Hashtable, IdentityHashMap, LinkedHashMap, PrinterStateReasons, Properties, Provider, RenderingHints, SimpleBindings, TabularDataSupport, TreeMap, UIDefaults, WeakHashMap 都是它的实现类。

遍历方法：
Map map = new HashMap();
        Iterator it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
    }
来个完整的，包含TreeSet的元素内部排序的
public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<String>();
       HashMap<Object,Object> hash = new HashMap<Object,Object>();
       TreeMap<Object,Object> treeMap = new TreeMap<Object,Object>();
       list.add("a");
       list.add("b");
       list.add("c");
       hash.put(3, 3);
       hash.put(4, 4);
       hash.put(5, 5);
       hash.put(6, 6);
       hash.put(1, 1);
       hash.put(2, 2);
       treeMap.put(1, 1);
       treeMap.put(2, 2);
       treeMap.put(3, 3);
       treeMap.put(4, 4);
       treeMap.put(5, 5);
       treeMap.put(6, 6);
      //list遍历
       for(String m: list){
        System.out.println(m);
       }
       // hashmap entrySet() 遍历
       for(Map.Entry<Object,Object> m: hash.entrySet()){
        System.out.println(m.getKey()+"---"+m.getValue());
       }
       //hashmap keySet() 遍历
       for(Object m: hash.keySet()){
        System.out.println(m+"---"+hash.get(m));
       }
       // treemap keySet()遍历
       for(Object m: treeMap.keySet()){
        System.out.println(m+"---"+treeMap.get(m));
       }
    }

  4.Swing界面相关,Swing组件的继承体系图、事件监听器的继承体系图。
继承的体系结构在Java里无处不在，在前面的I/O体系中，我们己经看到，在一个较高的抽像层面定义一个顶层类（父类）来规范所有子类的方法属性，就会使得对这些子类的使用有一个比较统一的方法，这在Swing体系里也不例外，所有的Swing组件都继承与Javax.Swing.JComponent这个抽像类 

Swing组件的继承体系图

要在Swing中处理事件，系统己为我们提供了常见的事件通知接口，我们的任务主要是实现相应组事的事件接口，比如所有的元素组件，都有一个.addActionListener(Java.awt.ActionListener listener) 方法，这个方法接收一个实现了Java.awt.ActionListener接口的对象，将这个对象加为某个组件的事件处理器，当一般的动作事件（如按键，鼠标单击）发生时，组件就会自动调用所加入的实现了ActionListener对象的事件处理方法。
每个Swing组件都有一个或多个add<事件名字>Listener(事件处理器类型 处理器)的方法，所要加入的事件事处器只要实现了理件接口即可；常用的JButton类、JList类(下拉框)、JMenu类(菜单)都有一个addActionListener(ActionListener listener)方法，基中ActionListener接口定义代码如下。
package Java.awt.event;
import Java.util.EventListener;
public interface ActionListener extends EventListener {
    /**
     * Invoked when an action occurs.
     */
    public void actionPerformed(ActionEvent e);
我们只要编写一个类实现这个接口---实现其中的actionPerformed方法即可，这个方法只有一个ActionEvent(事件对象)形的参数；这个ActionEvent对象有许多方法可以得到事件源的相关信息，ActionEvent对象的getSource()返回一个Object类型的对象，指向了发出这个事件的事件源，如是点击了一个JButton，就可以将这个Object强制转型为JButton类型，即可得到事件源对象；getActionCommand()方法可以得到事件源上的标签做为一个String类型，比如是一个菜单，就可得到菜单的标题。

  5.递归与循环的区别？
从程序上看，递归表现为自己调用自己，递推则没有这样的形式。 递归是从问题的最终目标出发，逐渐将复杂问题化为简单问题，最终求得问题是逆向的。 递推是从简单问题出发，一步步的向前发展，　最终求得问题。是正向的。 递归中，问题的n要求是计算之前就知道的，而递推可以在计算中确定， 不要求计算前就知道n。一般来说，递推的效率高于递归（当然是递推可以计算的情况下）

  6.I/O流继承体系结构图和分类。文件复制的实现，原始数据类型读写



文件复制的实现：
先说比较常用的方法：
  FileInputStream inputStream = new FileInputStream(srcFileName);
  FileOutputStream outputStream=new FileOutputStream(tagFileName);
        byte[] readBytes = new byte[1024];
        int readLength = inputStream.read(readBytes);
        while (readLength != -1)// 读取数据到文件输出流
        {
            outputStream.write(readBytes, 0, readLength);
            outputStream.flush();
            readLength = inputStream.read(readBytes);
        }
        // 关闭相关对象
        inputStream.close();
        outputStream.close();
这是使用标准io包的api进行文件的读写。
下面再看nio的读写方法：
        File in = new File(srcFileName);
        File out = new File(tagFileName);
        FileInputStream inputStream = new FileInputStream(in);
        FileChannel inChannel = inputStream.getChannel();
        long inputSize = inChannel.size();
        MappedByteBuffer inBuffer = inChannel.map(
                FileChannel.MapMode.READ_ONLY, 0, inputSize);
        // 使用通道方式复制文件
        FileOutputStream outputStream = new FileOutputStream(out);
        FileChannel outChannel = outputStream.getChannel();
        outChannel.write(inBuffer);
        // 关闭相关对象
        inChannel.close();
        inputStream.close();
        outChannel.close();
以前我用FileInputStream，在内存中弄一个很大的byte数组，读入后自己瞎搞拼装成int之类。现在发现其实完全没必要，java的io做得很完善方便了。DataInputStream里就有readInt，readFloat等方法。如果文件很大缓存不够会很慢，这时候可以用一个BufferedReader对象作为DataInputStream构造函数的参数，BufferedReader对象可以自由设置缓存大小。如此一来就又快又方便了。写的时候就用DataOutputStream和BufferedWriter。
 
7.线程：线程有几种创建方式？线程在程序中有几种状态？
方法一：继承Thread类，实现run方法。
创建并启动一个线程：
ThreadTestt=newThreadTest();
t.start();
方法二：实现Runnable接口的类，实现run方法
创建并启动一个线程：
RunTestr=newRunTest(143);
newThread(r).start();
在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。
第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态；
第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态
第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生（比如说某项资源就绪）之后再继续运行。sleep,suspend等方法都可以导致线程阻塞。
第五是死亡状态。如果一个线程的run方法执行结束，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪状态。 
  8.static用法与注意事项，==和equals的区别？
在Java语言中，static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。
static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名

==和equals的区别：
String s1 = new String("str");
String s2 = new String("str");
如果用==号比较，会返回false，因为创建了两个对象，他们在内存中地址的位置是不一样的。

equals的情况比较复杂，它是java.lang.Object类中的一个方法。因为java中所有的类都默认继承于Object，所以所有的类都有这个方法。
String里的方法，如果==号比较不相等，还会进行一下值的比较。
所以equals方法具体的作用要看当前的那个类是如何实现重写父类中该方法的。如果没有重写该方法，那么他和==号等价。