关于Java的一些零碎的笔记

时间 2019-11-13

标签关于 java 一些零碎笔记栏目 Java 繁體版

原文原文链接

代码简洁，思惟清晰，习惯注释
命名习惯：
       1.包名：全部字母一概小写；
       2.接口名和类名：每个单词首字母大写，若含有缩写，则每一个缩写字母均大写；
       3.方法名和变量名：第一个单词首字母小写，后面的每个单词的首字母均大写；
       4.常量名：每个字母都要大写，如有多个单词，以“_”链接
       5.命名要见名知意
eclipse快捷键：
   1.删除不引用的包/补上要引用的包：Ctrl+Shift+O
   2.单行注释：Ctrl+/
   3.多行注释：Ctrl+Shift+/，取消多行注释：Ctrl+Shift+\
   4.命令补齐：Alt+/
方法前若是有static修饰，那么能够用类名.方法来调用。
方法前有final，那么不能重写该方法
类名前有修饰符public时，类名必须和文件名一致。
当用cmd来编译Java文件时，出现没法加载主类的状况时，是因为classpath设置的缘由，用set classpath把classpath清除掉。
标识符不能使用数字开头，不能使用关键字，Java是严格区分字母大小写。
文档注释：/**注释*/，用javadoc命令能够把文档注释的内容抽取出来成为HTML格式。注释的内容不会编译到字节码文件里面，即注释多不会形成Java文件变大。
多行注释里面不能包含多行注释。注释是以/*开始，以*/结尾。注释能够用来缩小错误代码的范围。
定义常量方式：1.final 数据类型常量名 = 值；2.final 数据类型常量名；常量名 = 值；常量不能当作变量来改变值。
java基本数据类型：整数类(byte,short,int,long),文本类(char),浮点类(float,double)和逻辑类(boolean)
在有static修饰的方法里面调用其余方法时，调用的方法也要有static修饰。
instanceof是用来判断一个类是否属于一个类或者其子类。
构造函数：
   1.构造方法名要与类名一致
   2.构造函数的声明处不能有返回值，包括void
   3.不能在构造函数中使用return返回一个值
   4.构造方法不能被static，final，abstract，native和synchronized修饰
抽象类(abstract)：
   1.只定义方法声明但不包含方法体，这样的方法称为抽象方法
   2.抽象类能够不含有抽象方法，也能够存在一个或者多个抽象方法
   3.abstract关键字不能修饰属性和构造方法
包(package):
   1.导入包的时候不能直接导入方法，但能够静态引入
   2.静态引入：在import关键字后加上static，就能够引入方法，但该方法须要是一个公共静态(public static)方法或(public static final)常量
接口(interface)：
   1.若是一个抽象类里的全部方法都是抽象的，那么用interface来建立这个类
   2.接口里的方法默认是public abstract，能够不写，系统会默认声明这些修饰符
   3.接口里面能够有成员变量，方法默认的修饰符是public static final；
   4.接口能够支持多继承，类只能支持单继承
   5.类与类之间的关系是继承，用extends实现；类与接口之间的关系是实现，用implement实现
   6.接口的方法都是抽象方法，即没有方法体，以分号结束，不能出现{}
   7.interface的修饰符不能使用private和protected，通常建议用public
   8.接口名前建议加“I”，这样比较规范。
异常(Exception)
   1.异常类都是继承自Throwable类，异常分为error和exception。
   2.error 不能被抛出，exception能够抛出，exception类分为(非检查类)RuntimeException类和(检查类)其余异常类。
   3.处理异常
       try-catch以及try-catch-finally
       try{
           //一些会抛出异常的方法
       }catch(Exception e){
           //处理该异常的代码块
       }...
           catch(Exception e){
           //处理该异常的代码块
       }
       try-catch以及try-catch-finally后面的代码会执行，而不会中断。而且catch里的Exception须要按从小到大的顺序，由于异常的父类是Exception，全部子类都继承它，catch会寻找最近的Exception
throw和throws:
   1.throw关键字做用在语句上面，而throws关键字是做用在方法上面
   2.throw用于抛出异常，throws用于标志某个方法可能会抛出异常
内部类
   1.内部类的对象能够访问其所在的外部类的全部属性，包括私有属性
   2.外部类要访问内部类的属性和方法就必须先有对象再经过对象来访问属性和方法java

多线程
   建立线程的两种方法：
       1.继承Thread
       2.实现Runnable接口
   Thread
   启动线程：经过调用Thread的start()方法   数组

   一.继承Thread
       1.建立一个类继承Thread
       2.重写run方法
       3.建立一个线程对象，而后调用start()方法启动线程
   二.实现Runnable接口
       1.建立一个类实现Runnable接口
       2.重写run方法
       3.建立一个任务
       4.建立一个Thread对象，把第三步建立的任务传递给这个类
       5.调用start()方法，启动线程
   线程的状态：
           新建状态
           就绪状态
           运行状态
           阻塞状态
           死亡状态
   java线程的命名规则：Thread-i
   Thread.currentThread();获取当前正在执行的线程对象的引用
   线程是相互独立的，一个线程的操做不会影响其余线程，即一个线程出现了异常，不会影响其余线程的进行
   main方法执行结束后，jvm是没有中止运行的。还会运行其它的线程。
   一个线程对象只能调用一次start()方法，若屡次调用会抛出异常"IllegalThreadStateException"。
   Runnable接口中只有一个抽象方法run()。
   线程的run方法不能抛出异常，由于父类Thread里的run方法原来没有抛出异常，重写run方法时不能加上异常。
   在继承Thread类来建立线程中，经过关键字static能够实现数据共享，但不建议这样作，由于这样会使内存负荷
多线程安全问题：
       多线程安全问题产生缘由：
       1.必须有多线程的状况，并且有共享资料
       2.多线程执行代码多于一行
   线程同步锁：
       synchronized(对象){
           同步代码块
       }

       当synchronized用在函数上时，锁住的是当前对象，这时使用这个函数后每次只能运行一个线程，即只要有一个线程进入这个函数，那么其余线程必须等这个线程执行完后，才能进入这个函数
       在使用同步锁的时候，用的锁对象必定要是同一个对象
       当使用同步方法的时候，其实锁对象是当前对象（this）
       当使用静态的同步方法的时候，其实锁的对象是类的字节码文件对象
       发生死锁：多线程，锁嵌套
   线程间的通信：
       wait();
       notify();
       notifyAll();   安全

自动装箱：当基本数据类型赋值给对象类型的时候，基本数据类型会自动装箱成对象类型
自动拆箱：当基本数据类型和对象类型进行运算时，对象类型就会被自动拆箱为基本数据类型数据结构

   数组查询数据效率比链表高，链表插入删除数据效率比数组高。
-------------------------------------------------------------------------------------------------------------
java.util包下：
   Set
       HashSet：
           数据结构是hash表，往HashSet里面存放元素的时候，会先调用对象的hashcode方法，获取哈希值，经过哈希值算出元素在hashset里面的索引。若是相等，不存；不相等，经过其余的方法把元素存入hashset。若是两个元素的索引不相等，不调用equals方法直接存入hashset中。
       TreeSet:
           数据结构是二叉树，多线程

泛型：jdk1.5以上版本出现的一个彻底机制。
   好处：一、把运行时异常ClassCastExcetion转换到编译时异常。提升安全性。
   二、避免强制类型转换。
   <>:何时使用<>？
   <>,当程序操做的引用数据类型不肯定时，就可使用<>来限定，把须要操做的数据类型传入就好了。
   <>是控制引用数据类型的参数范围的。
一、泛型是用于编译时期的安全机制。不是运用于运行时期的。
在生成的class文件中是不存在泛型的。为何？可以兼容jdk1.5之前的版本。---泛型的擦除。
在迭代的时候，jvm会把擦除的泛型还原，以便迭代的时候可以明确类型-----泛型的修补。

2.泛型类：class 类名<E>{
}   app

3.泛型方法：修饰符 <E> 返回值类型方法名称（）{
}

泛型声明只能放在修饰符后，返回值类型前。

4.泛型通配符。用？表示接受的类型不肯定。可是注意，不能使用？类型声明对象。
泛型上限。? extends 类:只能接受指定类型或者是指定类型的子类对象。
泛型下限。? super 类：只能接受指定类型或者是指定类型的父类对象。eclipse

Map接口：
       Collection一次只能添加一个元素，Map一次能够添加一对元素。
       public interface Map<K,V> 将键映射到值的对象。一个映射不能包含重复的键；每一个键最多只能映射到一个值
   方法：
   1.添加元素
       V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操做）。
   返回值V：之前与 key 关联的值，若是没有针对 key 的映射关系，则返回 null。（若是该实现支持 null 值，则返回 null 也可能表示此映射之前将 null 与 key 关联）。
       void putAll(Map<? extends K,? extends V> m) 从指定映射中将全部映射关系复制到此映射中（可选操做）。
   2.删除元素
       void clear()
今后映射中移除全部映射关系（可选操做）。
V remove(Object key)
若是存在一个键的映射关系，则将其今后映射中移除（可选操做）,返回对应Key所对应Value的值。
3.判断
   boolean containsKey(Object key);
若是此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value);
若是此映射将一个或多个键映射到指定值，则返回 true。
boolean isEmpty(); 判断是否为空

4.获取
   V get(Object key);
返回指定键所映射的值；若是此映射不包含该键的映射关系，则返回 null。
int size(); 获取长度。 jvm

Set<K> keySet() (拿的是键的集合)
返回此映射中包含的键的 Set 视图。(Set集合里存放的是惟一值，键是惟一值)
使用KeySet能够把键所有放到Set集合中，由于Set集合里有迭代器，能够调用迭代器。用key来接收it.next();调用get(key)来获取键所映射的值函数

Set<Map.Entry<K,V>> entrySet() (拿的是映射的集合) Entry是Map的内部类
返回此映射中包含的映射关系的 Set 视图。
使用Map.Entry能够把键和值所有放到Set集合里，调用Set里的迭代器，Map.Entry下有getKey()和getValue()，分别获取键和对应的值
Collection<V> values() (拿的是value的集合)
获取Map集合中全部的value的值并放入Collection中 (Collection里存放的值不是惟一值，值是不惟一的)this

Map下经常使用的子类：
   |-----Hashtable   数据结构是Hash表，键和值不能为空，惟一，同步，JDK1.0版本
   |-----HashMap   数据结构是Hash表，键和值能够为null，不一样步，无序
   |-----TreeMap   数据结构是二叉树，键和值不能为null，无序，能够对键进行排序，不一样步
       Map<Integer,String> mp = new HashMap<Integer,String>(); 注意泛型只能用引用数据类型，不能使用基本数据类型
IO
   设备之间数据传输
   Java里面的数据是以流来实现传输
   流对象在Java.io包里
   按照流向分类：
       1.输入流：从其余设备读取文件到Java程序
       2.输出流：从设备写数据到其余设备

   按照文件处理方式分类：
       1.字符流：专门处理纯文本数据
       2.字节流：以字节为单位处理数据

字节流主要有两个类：
1.Reader----Input
2.Writer----Output

凡是与IO操做的代码都会发生异常(好比写入盘符错误等)，因此在写代码时要抛出异常。输出流会把写入的数据先放到缓冲区里，要调用刷新缓冲区的方法才能把数据写入到文件中
在操做完数据以后要记得关闭流(close()方法)，关闭流以前会先刷新缓冲区
Windows下换行的转义字符是\r\n。这是不一样操做系统内部对转义字符设置的不一样形成的
FileWriter(String fileName, boolean append)
append表示是否以追加模式来建立流对象，若是为true，则表示会在已有的数据上追加数据，若为false则会覆盖原来的数据

private static final String LINE_SEPARATOR = System.getProperty("line.separator");获取系统的换行符

read()一次读取一个字符，并返回读取字符的整数表示形式。若读到末尾，则返回-1。
字符数组在定义长度时取1024
复制的原理：循环读写
装饰模式
BufferedWriter里的一个方法void newLine() 能够换行
java里面有两种方式显示路径：/和\\。
使用系统的输入输出流不用关闭流，使用字符的输出流要刷新，使用字节的输出流不用刷新。
String里面有将字母转化大小写的方法，toUpperCase和toLowerCase

递归：函数调用本身（注意使用条件，不然会形成栈溢出；使用递归次数不宜太大，不然一样会形成栈溢出）