Java基础学习笔记

最近在学习大数据，然后就学习了一下java基础，下边是基础笔记：

java学习笔记：

<chp1>
1>java + 类名：执行时不要带".class"，否则报错。
2>javac编译".java"文件时，文件中的类会被分别编译成对应的"类名.class"
3>类或接口为public时，必须与文件名一样，包括大小写。一个文件只能有一个公开类或接口。

<chp2>
1>注释：注意是javadoc的注释方式：/** */
2>package包：(必须在文件开始声明)
①便于对class文件管理，但注意必须与文件目录一直才行，否知执行报错
②包可以防止类名冲突。
③命名原则：与网址相反，abc.com 对应 com.abc.corejava
3>import包：
①当package出现，package存在文件的开始位置，import排在其后。
②import 可以导入某包内的一级类，如 "import java.util.*"，但注意不会导入其下的子包中的类。
③默认情况下，已经导入"import java.lang.*",不需要自行导入。
4>java是区分大小写的
5>命名规范：包、类、方法、变量、常量
①包名：全小写
②类名：大骆峰
③变量/函数名：小骆峰
④常量：全大写，单词间下划线隔开。HELLO_WORLD
6>数据类型：
①8中基本数据类型
②String类："+"可以拼接字符串与任何类型，结果都是字符串。
③局部变量：必须先复制后使用，否则编译报错。作用域是从声明开始到该级别代码块结束，包括子代码块中。

<chp3>
①Scanner
<chp5>
1>数组:
①隐式初始化时，不能指定数据大小，JVM根据实际参数格式分配
②二维数组中支持不规则数组

<chp6>对象和类
1>成员属性：可以在代码中直接初始化（与C++不同），并且不会与方法中的变量冲突。
2>成员方法：
①重载：方法名相同，参数列表不同。
②构造函数：和C++一样，可以重载构造函数，有默认的无参构造函数。
3>对象创建过程：
①根据类属性大小，分配内存，设置默认值:bool的为false,int的为0
②根据代码，初始化成员变量。
③调用构造函数。
④引用:与C++一样作用，只是方式不太一样，引用传递
④this:this()只能在构造函数使用，表示调用本类的其他构造函数，完成对象的构造
只能用在构造函数的第一句，否则报错。
注意不能在构造函数中通过this()调用自己，这样递归是有问题的。
<chp7>面向对象的三大特性
1>封装：
①问修饰符：
private：类内部
public：都可以通过对象访问
default：类内部，同包范围内，当继承的父类是在其他包中时，子类是无法访问defalut的成员变量的。
protected：类内部，同包内部，不同包的子类中。
2>继承：
①extends:
②覆盖：方法覆盖对方法的5部分都有要求，访问修饰符、返回值、函数名、参数列表、异常
③对象创建过程：
->分配空间，赋默认值
->由根至子，依次初始化
->由根至子，依次调用构造函数
调用父类构造函数的时候，默认的调用无参构造函数，
如果需要调用指定的构造函数，使用super(参数列表)调用
注意：在使用super时，必须作为构造函数的第一句。
以为值this和super在构造函数中不能共存。
构造函数的第一句，有三种互斥情况：
①super(参数)
②this(参数)
③前两者都不是，编译器自动加上super(),即调用父类的无参构造函数。
->super是指向父类的引用，this是指向子类的引用。
->java是单继承，与C++多继承不同。
3>多态：父类引用引用子类对象，只能调用父类定义的方法，但方法可能被子类重写，此时调用的就是被重写的方法。
①instanceof: 对象的引用 instanceof 类，返回值为bool类型。
②多态的N种方式：
->父类引用 指向子类对象，可能是多层继承关系
->接口引用 指向实现类的对象，多继承关系多层继承关系；
->方法多态：重载和覆盖（可以super调用父类被覆盖的方法，从而实现对父类方法的扩充）

<chp8>三个修饰符：static、final、abstract
1>修饰的对象：
①static:属性，方法，初始化代码块；注意其不能修饰局部变量和类。
②final：变量（包括属性和局部变量（方法参数也是局部变量）），方法，类
③abstract:类，方法
2>含义
①static：
->属性：静态成员变量，类变量，是所有对象共有的。相反，非静态属性，是实例变量
->方法：非静态方法，无论属性和方法是否静态，都能访问。
静态方法，只能访问静态属性和方法.
->初始化代码块：初始化代码块，就是在类中，方法外的，{}内的代码块
静态代码块，在类加载的时候只执行一次；
非静态代码块，在类加载的时候执行多次。
②final:类似const
->局部变量：一次赋值机会，以后只读；
->属性：对象创建完成之前有一次赋值机会，即初始化属性或者构造函数中；
属性没有默认值，所以必须在建立对象之前，完成对属性的赋值，否则编译器报错；
如果未初始化属性，则所有构造函数都需要实现对其的赋值,注意此时构造函数是不能相互调用的；
注意：因为静态属性是在类加载的时候分配空间的，因此static final 属性只能初始化赋值；
->方法：修饰方法表示子类无法重写父类的该方法；
->类：表示该类不能被继承；
③abstract:类似C++ virtual
->类：表示是抽象类，不能实例化，但可以申明引用，指向子类对象。即C++中含有纯虚函数的类为抽象类
->方法：表示方法只是声明，没有实现，需要子类实现，该类无法创建对象；
抽象方法必须是在抽象类中，但抽象类不一定含有抽象方法；与C++不太相同
子类继承抽象类，要么成为抽象类，要么必须实现全部抽象类的抽象方法；

<chp9>接口
1>接口：特殊的抽象类，即：
所有属性都是public static final修饰
所有方法都是public abstract 修饰
2>声明方法：interface 接口名
3>注意：
->interface 与符合要求的abstract class类似，但声明时可以省略访问修饰符；
即：属性 省略public static final
方法 省略public abstract
->类实现接口，使用关键词：implements
->一个类实现接口，如果不希望其为抽象类，则必须实现全部方法；
->因为接口方法是public的，所以实现类中的实现方法必须使用public修饰；
->接口之间也存在继承，使用关键词extends;
->接口继承可以是多继承的；
->类是单继承，接口可以多继承，且子类继承父类，实现接口时，继承在前，实现在后，否则编译出错；

4>关于java类的单继承，接口的多继承 与 C++类多继承的思考：
①java类继承时主要类型，接口是次要类型；
②基类是事物主要共性的抽象，接口是次要共性的抽象；
③单继承，父子类之间是简单的树形结构，及时是接口的多继承也不会破坏这个树形关系；
④接口解耦合，其实就是多态。接口就是方法的抽象的集合，是需要实现的标准；
当接口的实现这变化的时候，对接口的使用者不产生影响；
与代理模式极其相似，声明代理，就是声明接口，实现代理就是实现接口，从而降低使用者和实现者的耦合关系；
对于项目开发而言，可以实现多个模块或者系统的并行开发工作，提高开发效率；
⑤接口回调:实际就是系统库中，定义接口，调用调用者的实现，从而实现接口的回调。
与C++ stl模板库中算法中排序，也是这种思想；
⑥泛型：接口调用时，很多是工具类封装的接口，程序实现接口，但是为了工具类的扩张性，
以Comparable接口为例，接口定义的是泛型型的，实现是需要类型化
与C++的模板库中的模板思想是一致的；

<chp10>Object物种起源

1>finalize:JVM垃圾回收时调用，SUM的垃圾回收是内存不足是回收垃圾
所以，释放资源，最好调用System.gc()方法，但也不是马上释放资源，只是通知垃圾回收机制需要释放资源了。
2>getClass:与instanceof类似，不同在于前者可以精确判断引用的真是类型，后者只能判断引用是否是某个类的实例，不能精确判断是那个类的实例，因为后者在判断是父类的实例时也返回true
3>equals:注意与"=="的区别，前者是比较引用对象的值是否相等，后者是比较引用对象的地址是否相等；
自定义类时，如果用到equals方法，则需要覆盖父类的equals方法：
覆盖equals的五个步骤：
①判断 this == obj
②判断 obj == null
③判断两个对象的实际类型（getClass）
④强制类型转换
⑤判断两个对象的属性是否都相等
4>toString:类似OC的description；
5>封装类：Object类型的引用可以指向任意类型的对象，但是在指向基本数据类型的时候力不从心，
所以，Sun封装了八大包装类，实现Object类对八大基本基本数据类型的引用；
6>数据类型转换：①字符串，②包装类，③基本数据类型
①<->②：前者直接调用包装类的构造方法；后者调用toString方法
①<->③：前者是对应调用Integer.parseInt(str)；后者调用：""+数据 或者调用静态方法String.valuesOf(数据)；
②<->③：前者调用构函数；后者类似intValues()方法即可；
7>自动封箱和拆箱：JDK5后新增特性，可以隐式实现包装类和基本数据类型的装换,其实是编译器处理过，底层实现还是一样的
如：int i = myInteger; myInt++;
目的是更加方便的操作基本数据类型和包装类。
8>四种内部类：和C++的内部类基本类似,实用性不强，暂时不看

<11>集合框架：类似C++ STL
1>系统接口
①Collection:数据是object类型
->List:有序
->Set:无序，唯一
->SortedSet：有序，唯一
②Map:数据是键值对类型
->Map:键不能重复
->SortedMap:键对象按照排序规则，自动排序
2>详细方法介绍：
①Collection接口:
->add
->contains
->isEmpty
->iterator 迭代器
->remove
->clear
->size
②List接口：
->add(Object),add(index,Object) :前者是继承，后者是新增
->get(index),set(index,element):前者是获得
->indexof(Object):查找对象
->实现List接口的的类：注意泛型，就是模板思想
①ArrayList：底层实现线性表，查找快，增删慢
②LinkedList：底层实现是链表，增删快，查找慢
③Vector：底层实现线性表，与ArrayList类似，但线程安全
③Set接口：
->add(Object)
->实现Set接口的类：
①HashSet:自定义类时，需要重写覆盖父类的equals和hashCode方法，否则无法满足Set特性；
因为HashSet的特性是，首先判断其hashCode的值是否相同，如果相同，再调用equals判断；
如果不重写equals和hashCode方法，则会调用父类的该方法；
->SortedSet接口：元素不重复，并且经过排序
->实现SortedSet接口的类：TreeSet，该类中存放的对象都必须实现Comparable接口；

②Map接口:
->Object get(Object key)
->put(Object key,Object value);如果键值不存在则插入，如果存在则更新其值
->remove(Object key)
->Set keySet();获得key的集合
->Collection values();获得所有值value的集合，因为可能重复，不能是Set.
->containsKey/containsValue
->size;键的个数
->isEmpty;
->clear
->entaySet
->Map的实现类：
①HashMap:键值对中的key必须重写equals,hashCode方法，线程不安全，null可以作为键/值;
②LinkedHashMap：可以保证放入键值的顺序
③HashTable：线程安全，null作为键/值时抛出异常
->Map.Entry是Map的内部接口
->SortedMap子接口：有序
->实现类是TreeMap:意味着放入的对象必须实了Comparable接口；
3>foreach遍历集合:
for(Object obj : set){
System.out.println(obj);
}
4>泛型：就是C++模板思想，泛型不能多态；

<shp12>异常处理：程序的白衣天使
1>异常分类：
Throwable类:所有错误的父类
|-Error:严重底层错误，无法处理
|-Exception:异常，异常处理的主要对象
|-RuntimeException:未检查异常，可以避免，可选择处理,编译可以通过。
|-非RuntimeException：无法避免的异常，必须处理，否则编译不通过
2>抛出异常后，异常对象会沿着方法调用链反向传递。当异常都没有处理，抛给你了虚拟机，则虚拟机只能停止当前程序。
3>捕获异常：try{可能不是全部代码都执行} catch(){异常处理} finally{一定执行的代码，主要是释放资源，事务处理}

<shp13>多线程 2种方式：
1>继承Thread类,注意Thread类不是抽象类，重写run()方法，使用start启动线程！
2>实现Runnable接口，实现run()方法，使用run启动线程
3>线程状态。阻塞：sleep()，join()
4>同步和互斥。
①synchronized(lock){}同步代码块与synchronized访问修饰符，实现互斥资源的互斥访问
②wait,signalAll();实现同步；

<shp14>I/O框架
1>File类：表示文件和文件夹
2>字节流：
1> 抽象类 其子类 构造函数 其他
InputStream： FileInputStream String filename;File file; close;read
OutputStream： FileOutputStream String filename;File file; close;write
2>字节过滤流：
->增强读写八种基本数据类型和String
DataInputStream: readInt等
DataOutputStream: writeInt等
使用步骤：①创建节点流，②封装过滤流，③读写数据，④关闭外层流（内存流自动关闭）
->提高I/O的读写效率：注意①缓冲区满 ②调用close ③flush方法 会清空缓冲区，完成读写
BufferedOutputStream:
BufferedIntputStream:
->增强基本数据类型，String,缓冲区功能，对象的读写,对象序列化：
ObjectInputStream: readObject();
ObjectOutputStream: writeOject();
注意：实现了java.io.Serializable接口的对象才能序列化。当属性被transient修饰时，才不参与序列化。

4>字符流：
1> 抽象类 其子类 桥转换（字节流转为字符流）
Reader: FileReader, InputStreamReader
Writer: FileWriter, OutputStreamWriter
2>字符过滤流： 方法
->BufferReader: String readLine()
->PrintWriter:

<chp15>网络编程
1>TCP ：ServerSocket Socket getInputStream 桥转换和过滤流，使用BufferedReader和PrintWriter进行IO操作
1>TCP服务器端：
①创建ServerSocket对象,绑定端口
②调用accept,等待请求
③调用getXXXStream，io
④关闭socket
2>TCP客户端：
①创建socket对象，连接服务器
②调用getXXXStream方法，IO
③关闭Socket;

2>UDP:DatagramSocket DatagramPacket进行IO的操作

1>UDP服务器：
2>UDP客户端：

3>URL:
URL url = new URL("http://www.sina.com.cn");
URLConnection conn = url.openConnection();
InputStream in = conn.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));

<shp16反射>
1>class：泛型，Class<?>
1>类对象获取方式：
①类名.class;
②对象.getClass();
③Class.forName();
2>类名和接口名的获取：
①getName();
②getSimpleName();
③getSuperclass().getName()
④getInterfaces();
2>方法：Method
1>获取方法：
①getMethods:获取所有的该类和从父类继承的非private修饰的方法数组
②getDeclaredMethods:获取该类中申明的所有方法的数组，不包括从父类中继承的。
③getMethod(方法名,参数类对象数组):因为存在重载，所以需要参数类对象数组，方法的范围同上描述
③getDeclaredMethod(方法名,参数类对象数组):因为存在重载，所以需要参数类对象数组，方法的范围同上描述
2>获取方法名：
①getName:获取方法名，不包括包名
②toString:获取方法的签名
2>使用方法：
invoke(对象,参数列表Object数组)：方法、对象、参数值
3>属性：Field
1>获取属性：
①getField(String):获取类的对象及从父类继承的非private属性
②getDeclaredField(String)：获取类的对象所有属性，不包括继承的；
2>操作属性：
①Get:直接获得即可
②Set:对于私有属性，使用之前设置setAccessible(true)，才能对其属性赋值；
4>构造函数：Constructor
1>获取构造函数：
Constructor con = c.getConstructor(new Class[]{String.class,int.class});
2>使用构造函数：
①con.newInstance(new Object[]{"Cz",new Integer(28)});
②c.newInstance();//无参构造函数
5>应用；
String className = "Student";
Class<?> c = Class.forName(className);
Object o = c.newInstance();
//注意className，必须是完整的类名，包括包名；
String methodName = "study";
Method m = c.getDeclaredMethod(methodName,new Class[]{});
m.invoke(o,new Object[]{});

将类名和方法字符串化，实现代码的复用，多态的体现。和OC中通过方法名或者属性名操作对象类似。

反射是底层操作，虽与封装思想相违背，但它是底层的操作，可以提高代码重用，多用于工具和框架；
反射不足：效率较低，比较复杂，不易调试；

<chp17>OOAD:面向对象的分析与设计
1>设计模式：
①单例：
public class Singleton{
private Singleton (){}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
②简单工厂模式
2>数据分3层：通过反射机制，实现修改配置文件，即可修改系统的三层中的处理方式。
①DAO:
②BO(biz):
③VO:

 

最后一个简单的三层代码：

接口部分：

package dao;

public interface Dao{
        String getData();
}

 

package biz;
import dao.Dao;

public interface Biz{
        void setDao(Dao dao);
        String dealData();
}

 

package view;
import biz.Biz;

public interface View{
        void setBiz(Biz biz);
        void showData();
}

 

实现类：

---

 

package dao;
//放在同一个报下
//import dao.Dao;
import java.io.*;


public class FileDaoImpl implements Dao{
        public String getData(){
            String data = "";
            BufferedReader br = null;
            String tmp = "";
            try {
                br = new BufferedReader(new FileReader("test.txt"));
                while((tmp = br.readLine()) != null)
                {
                    //System.out.println(tmp);
                    //System.out.println(data);
                    data += tmp;
                    data += '\n';
                }
            } catch (IOException e) {
                 e.printStackTrace();
            }finally {
                 if(br != null){
                     try {
                         br.close();
                     } catch (IOException e) {
                          e.printStackTrace();
                     }    
                 }
            }
            
            return data;
        }
}

 

package dao;
//放在同一个报下
//import dao.Dao;
import java.io.*;
import java.net.*;


public class NetDaoImpl implements Dao{
        public String getData() {
            String data = null,tmp = null;
            URL url = null;
            URLConnection conn =null;
            InputStream in = null;
            BufferedReader br = null;
            
            try {
                url = new URL("http://www.sina.com.cn");
                conn = url.openConnection();
                in = conn.getInputStream();
                br = new BufferedReader(new InputStreamReader(in));
                String line = null;
                
                while((tmp = br.readLine()) != null){
                        data += tmp;
                    }
            } catch (Exception e) {
                 e.printStackTrace();
            }
            finally {
                try {
                    if(br != null){
                        br.close();    
                    }
                } catch (Exception e) {
                      e.printStackTrace();
                }
                 
                 return data;
            }
            
            
            
        }
}

 

---

package biz;
import dao.Dao;

public class UpperCaseBizImpl implements Biz{
    private Dao dao;
    
    public String dealData(){
        String data = dao.getData();    
        if (data != null) {
             data = data.toUpperCase();
        }
        return data;
    }    
    public void setDao(Dao dao){
        this.dao = dao;    
    }
}

 

package biz;
import dao.Dao;

public class LowerCaseBizImpl implements Biz{
    private Dao dao;
    
    public String dealData(){
        String data = dao.getData();    
        if (data != null) {
             data = data.toLowerCase();
        }
        return data;
    }    
    public void setDao(Dao dao){
        this.dao = dao;    
    }
}

 

---

package view;
import biz.Biz;

public class TextView implements View{
    private Biz biz;
    
    public void setBiz(Biz biz){
        this.biz = biz;    
    }    
    public void showData(){
        System.out.println( biz.dealData());    
    }
}

 

 

---

工厂类：

package simplefactory;
import dao.*;
import biz.*;
import view.*;
import java.util.Properties;
import java.io.*;

//单例模式
public class SimpleFactory{
    {
        props = new     Properties();
        InputStream is = null;
        try {
            is = new FileInputStream("conf.props");
            props.load(is);
        } catch (IOException e) {
             e.printStackTrace();
        }
        finally {
             if(is != null){
                 try {
                     is.close();
                 } catch (Exception e) {
                      e.printStackTrace();
                 }    
             }
        }
    }
    private static Properties props;
    private SimpleFactory (){}
    private static SimpleFactory instance = new  SimpleFactory();
    public static SimpleFactory getInstance(){
        return instance;
    }
    public static  Object createObject(String name){
        Object obj = null;
        String objName = props.getProperty(name);
        try {
            Class c = Class.forName(objName);
            obj = c.newInstance();
        } catch (Exception e) {
             e.printStackTrace();
        }    
        return obj;
    }
}

/*
public class SimpleFactory{
    private Properties props;
    
    public SimpleFactory(){
        props = new     Properties();
        InputStream is = null;
        try {
            is = new FileInputStream("conf.props");
            props.load(is);
        } catch (IOException e) {
             e.printStackTrace();
        }
        finally {
             if(is != null){
                 try {
                     is.close();
                 } catch (Exception e) {
                      e.printStackTrace();
                 }    
             }
        }
    }
    public static Dao createDao(){
        return new     FileDaoImpl();
    }    
    public static Biz createBiz(){
        //return new     UpperCaseBizImpl();
        return new     LowerCaseBizImpl();
    }    
    public static View createView(){
        return new     TextView();
    }    
    public  Object createObject(String name){
        Object obj = null;
        String objName = props.getProperty(name);
        try {
            Class c = Class.forName(objName);
            obj = c.newInstance();
        } catch (Exception e) {
             e.printStackTrace();
        }    
        return obj;
    }
}
*/

 

测试类：

package test;
import dao.*;
import biz.*;
import view.*;
import simplefactory.SimpleFactory;

public  class TestMain {
     public static void main(String [] args){
         Dao dao = (Dao)SimpleFactory.createObject("dao");
         Biz biz = (Biz)SimpleFactory.createObject("biz");
         biz.setDao(dao);
         //View view = (View)SimpleFactory.createObject("view.TextView");
         View view = (View)SimpleFactory.createObject("view");
         view.setBiz(biz);
         
         view.showData();    
     }
}

 

编译的时候，我使用的dos命令javac命令，注意加"-d ."，编译器自动在当前目录下创建包名对应的文件夹，并将类文件放入其中。

配置文件：

dao=dao.NetDaoImpl
biz=biz.LowerCaseBizImpl
view=view.TextView