java学习笔记整理

Posted 2020-07-17 乐之者

java知识模块：
1.基础知识，数组，字符串，正则表达式；
2.类和对象，接口，继承，多态，抽象类，内部类，泛型，java常用类库。
3.异常处理； 4.IO；   5.事件处理；   
6.多线程；  7.集合类  8.网络通信；   9.JDBC操作数据库

一、idea技巧
1.设置字体大小:
file -> setting -> editor -> colors&font -> save as并自定义 -> font -> 修改size大小
改变背景颜色：
file -> setting -> editor -> colors&font -> general -> text -> default text ->勾选Background
2.alt+enter自动导入类;

eclipse技巧
1.alt+/  可以快速修正。
  输入Sysout，再按下alt+/,就可以打印了。
  输入main，再按下alt+/,可以直接显示main方法。
2.ctrl+ / 注释整行
3.调试技巧。双击蓝色竖条设置断点，F11进行调试，F6单步操作，F8 单步跳入。
4.用eclipse打开一个JAVA项目：File->Import->General->Existing Project into WorkSpace->（选中你的项目就行了）

              
二、类和对象
1.类是描述同一类型的对象的抽象概念，对象是类的一个具体实例。
2.对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体.
命名规范：方法和属性的第一个首单词小写，之后每个单词首字母要大写。比如getInfo();
3.当创建类时，就是在描述那个类的对象的外观与行为。执行new来创建对象时，数据存储空间才被分配，其方法才供外界调用。
4.构造方法的名称必须与类名完全相同 。构造方法没有返回值。
5.初始化切记：初始化的顺序是先静态对象，而后是“非静态”对象。
  对于静态变量、静态初始化块、变量、初始化块、构造器，
  它们的初始化顺序依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器。
6.栈内存：在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。
  在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。
  堆内存：堆内存用来存放由new创建的对象和数组。
7.使用get和set方法，是为了保证程序的封闭性和安全性。。
  如果直接把数据设为public ，那么数据很可能会混乱，无法维护。
8.产生随机数0到100
 Random rand = new Random();
 int m = rand.nextInt(100);
9.从键盘输入数据示例：
Scanner scanner=new Scanner(System.in);  //当程序进行到这里的会要求你从键盘输入什么东西 如果你输入和一个整形的数字 比如 150
int s=scanner.nextInt();     //带有校验功能
10.静态工厂方法：比较流行的规范是把静态工厂方法命名为valueOf或者getInstance。
Calendar cal=Calendar.getInstance(Locale.CHINA);
11.修饰符范围
private：当前类中才可以使用； public :完全公开；  protected:子类可以访问。
static(静态):修饰属性或者方法时，表示全类公有，相当于全局变量。
12.java具有自动的垃圾收集机制。


三、单例模式
懒汉式：private static Single single=null;
懒汉式：
public class Single {
   private static Single single=null;
   private Single() {}
   public static Single getInstance() {
      if(single==null)    single=new Single();      
      return single;
   }
}
恶汉式：private static Single single=new Single();
恶汉式：
public class Single{    
    private static Single  single=new Single();      
           private  Single()  {  }
           public static Single getInstance()  {           
                      return single;
            }
   }

四、泛型
1.泛型：在定义集合的时候同时定义集合中对象的类型。
2. List <?>
List<?> 这样去定义的话和List<Object>是一个意思，这样就可以避免到时候从list中取值使用的时候出现运行时异常，
加上泛型，定义之后，在往list中添加元素的时候就必须是定义的元素，否则编译会报错，例如定义List<String> a=new ArrayList<String>();
这样的话，a中就只能添加字符串，其它类型添加不了，特别作用就是避免运行时异常
 
五、抽象类
1.当一个类被声明为abstract时，称为抽象类。
  public abstract class leader{ }
2.抽象类不能实例化，而且抽象类中的方法只有方法名,没有方法体.
  public abstract void worker();
3.含有抽象方法的类，必须是抽象类.
 
六、内部类
1.每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个实现，对于内部类都没有影响。
匿名内部类也就是没有名字的内部类,正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写.
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

java反射机制：通过反射，可以在程序中访问已经装载在JVM中的java对象的描述，实现访问、检测和修改描述java对象本身信息的功能。
Class clazz=object.getClass();  //获得代表类的Class对象
StringBuilder sb=new StringBuilder();
Package packageName=clazz.getPackage();   //获取类所在的包名
Method[] methods=clazz.getDeclared
Methods();  //获取方法名数组
for(Method method:methods) {
  String modifier=Modifier.toString(method.getModifiers());   //获取修饰符
  if(modifier.contains("public")) { sb.append(method.toGenericString()+"\n");}   
}
 
七、继承
1.继承是所有面向对象语言，包括JAVA语言不可缺少的组成部分。
当创建一个类时，除非已明确指出要从其他类中继承，否则就是在隐式地从JAVA的标准要类Object进行继承。
2.为了继承，一般的规则是将所有的数据成员都指定为private,将所有的方法指定为public.
3.this 关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。
  super出现在继承了父类的子类中。super必须放在类的首行.
  super.xxx();(xxx为方法名) 意义为，直接访问并调用父类中的方法。
4.组合：只需将对象引用置于新中即可。在新类中嵌入的现有类的对象一般为private.
5."is-a"的关系是用继承来表达的。而"has-a"的关系则是用组合来表达的。
  如果一个类继承自另一个类，那么它们是“is-a”的关系，如果一个类的成员中引用了另一个类，那么它们是“has-a”的关系。

八、多态
1.多态，顾名思义，就是有多种表现形式。
  Dog jack=new Animal();
2.多态有两种表现形式：重载和重写.
  a.重载(overload),一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同.
  他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性.
  b.重写(override),发生在子类中,即有继承的情况下才有重写发生。继承一个类，也就有了父类了全部方法，
  如果你感到那个方法功能要变，那就把那个函数在子类中重新实现一遍。这样再调用这个方法的时候，就是执行子类中的过程了。
 
九、接口
1.Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现.
2.接口中的方法只有定义而没有被实现；
public interface Calculate{
   final float PI=3.14159f;
   float getArea(float r);
   float getCircumference(float r);
}
3.接口和抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以。

十、数组
1.数组的创建和初始化：
int month[]=new int[12];      //int month[]为声明部分，new int[]为分配内存。
int arr[]=new int[]{1,2,3,12,24};
2.length的用法。
int[] a=new int[10];int len=a.length;
这个是数组的length属性
String str="abc";int len=str.length();
这个是String的length方法
3.二维数组初始化，行数可以不写，但是列数必须写。     
4.数组的foreach用法。for(int k:arr)。
  int[] arr= {1,2,3,4,5};    
  for(int k:arr)   System.out.println(k);       //此处的k就是数组元素a[0],a[1]....
   相当于：
     int[] arr= {1,2,3,4,5};
       for(int i=0; i<arr.length; i++)
          {
            int k = arr[i];
            System.out.println(k);
          }
5.对数组进行排序，可以使用sort()方法;
  数组的复制，可以用copyOf()方法。
6.

十一、字符串
1.toString()是Object类里的方法。所有类都继承于Object，所以所有类都有toString()方法,该方法可以重写。
  toString()方法就是把对象转换成String类型，转换的算法根据类型和实际需要而定。
2.indexOf(char a)   //获取指定字符的索引位置
   lastIndexOf(char a)   //获取指定字符的最后一个索引位置
   charAt(int index)   //获取索引位置的字符
   replace()        //用于替换指定字符串
3.split用于分拆字符，该函数返回一个下标从零开始的字符数组，它包含指定数目的子字符串.
4.trim（）方法用于去掉字符串前面和后面的空格。
5.indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引。
6.StringBuffer类的方法setCharAt(int index, char ch):修改对象中索引值为index位置的字符为新的字符ch.
7.toUpperCase();转变成大写字母。toLowerCase();即变成小写。
8.比较运算符“=="比较的是内存位置，不适宜拿来比较字符串；
  equals（）方法比较的是两个字符串的内容。
9.StringBuffer类型转换为string，可以使用toString方法。
  append用于向StringBuffer对象添加字符串。deleteCharAt删除指定位置的字符。
  insert用于插入。delete删除。reverse用于反转字符串。
10.StringBuffer和StringBuilder区别：StringBuilder性能好，耗时少,线程不安全；StringBuffer耗时较久，线程安全。
  String 和StringBuffer的区别：
  String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串可以进行修改。
  当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。
11.CharSequence与String都能用于定义字符串，但CharSequence的值是可读可写序列，而String的值是只读序列。
12.int i=Integer.parseInt(str);    //将字符串转化为对应的数字
13.重写equals时，必须重写hashCode.
 equals和hashCode的关系如下所示：
a、如果两个对象相同，那么它们的hashCode值一定要相同；
b、如果两个对象的hashCode相同，用eqauls方法比较它们并不一定相同.  

十二、正则表达式；
1.为了检查输入的数据是否满足某种格式，可以使用正则表达式中的matches方法。
2.正则表达式的限定符，\\d{3}表示数字出现3次，\\p{Upper}{2}表示大写字母出现两次
String str="QQabc1234";
boolean b1=str.matches("\\p{Upper}{2}\\p{Lower}{3}\\d{4}");
3.Pattern是一个正则表达式经编译后的表现模式。
Pattern compile(String regex)  表示将给定的正则表达式编译并赋予给Pattern类。
Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。
运用示例：
String str="1983-07-27";    //检查日期格式是否正确
String pat="\\d{4}-\\d{2}-\\d{2}";
Pattern p=Pattern.compile(pat);   //先声明模式
Matcher m=p.matcher(str);    //接着再匹配
if(m.matches())  {
        System.out.println("日期格式各法");    
}else {
    System.out.println("日期格式不合法");
}


十三、异常处理
1.try  {可能出现错误的代码块}   catch(exception e){进行处理的代码} ；
                                对象变量的声明
用这种方法，如果代码正确，那么程序不经过catch语句直接向下运行；
如果代码不正确，则将返回的异常对象和e进行匹配，如果匹配成功，则处理其后面的异常处理代码。（如果用exception来声明e的话，因为exception为所有exception对象的父类，所有肯定匹配成功）。
处理完代码后这个例外就完全处理完毕，程序会接着从出现异常的地方向下执行（是从出现异常的地方还是在catch后面呢？利用程序进行验证）。最后程序正常退出。
Try中如果发现错误，即跳出try去匹配catch，那么try后面的语句就不会被执行。
2.e.printStackTrace()方法：在命令行打印异常信息在程序中出错的位置及原因

十四、输入/输出
1.字节输入流：InputStream
  字节输出流：OutputStream
  文件输入流：FileInputStream（只提供对字节和字节数组的读取方法）
  创建文件： File file=new File("E:/io操作");
  获取文件信息的方法：file.getName();   //获取文件名
                      file.exists();   //判断文件是否存在
  字符流:Write,Read
2.字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，
而字符流在操作时使用了缓冲区，通过缓冲区再操作文件
3.流是什么？流具有方向性，至于是输入流还是输出流则是一个相对的概念，一般以程序为参考，
如果数据的流向是程序至设备，我们成为输出流，反之我们称为输入流。
4.文件格式，可以右键文件，点击属性，查找到路径。如 F:\\IO操作\\fileStream.txt
5.read()方法读到末尾时，返回值是-1.
6. 检验文件是否存在。
   File file=new File("D:\\mywork\\work.txt");
     if(file.exists()) {      //
          file.delete();  System.out.println("文件已删除");
      } else {
            try{
               file.createNewFile(); System.out.println("文件已创建");
            } catch(Exception e) { e.printStackTrace() }
      
      }
7.  将字节数组放进文件输出流，才能写入数据。操作完毕，记得关闭流。
    还有，进行IO操作时，要加上异常处理。                  
        File file=new File("F:/IO操作","fileStream.txt");   //创建文件对象
        try {
            FileOutputStream out=new FileOutputStream(file);  //创建输出流对象
            System.out.println("请输入内容：");
            Scanner sc=new Scanner(System.in);           //从键盘获取数据
            byte byte1[]=sc.nextLine().getBytes();   //获取字节."IO操作的文件流和字节流"
            out.write(byte1);       //将字节数组写入到文件输出流中。  
            out.close();                //记得将流关闭。
            
            FileInputStream in=new FileInputStream(file);   //创建输入流对象
            byte[] byte2=new byte[1024];
            int len =in.read(byte2);    //获取文件长度.
            System.out.println("目标文件中的内容是："+new String(byte2,0,len));   //将字节数组转化为字符串
         }catch(Exception e){
              e.printStackTrace();
         }
8.字符流示例：
public class WriteDemo {
    public static void main(String[] args) {
           File file=new File("F:\\IO操作","work.txt");
          try{
           Writer out=new FileWriter(file);
           String str="hello world";
           out.write(str);          //字符流可以直接写入字符串，而不用字节数组
           out.close();        //字符流存在缓冲区，必须关闭流。
          }catch(IOException e){
              e.printStackTrace();
              
          }
    }
}        
        
十五、多线程
1.java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。
一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
调用Thread类的start()方法，就会执行线程，自动启动run()方法
为什么启动线程不直接使用run()方法？线程的运行需要本机操作系统支持。
2.对象“互斥锁”，保证共享数据操作的完整性，“互斥锁”的标记保证在任一时刻，只能有一个线程访问该对象。
3.关键字synchronized用于对象的互斥锁联系，当某个对象有synchronized修饰时，表明该对象任一时刻只能由一个纯程访问。（程序锁）
4.Wait和sleep的区别：wait时别的线程可以访问锁定对象，而sleep时别的线程不可以访问锁定对象。
5.notify用于唤醒wait的进程。thread.yield()暂停当前正在执行的线程对象，并执行其他线程


十六、集合
1.ArrayList和Vector都是使用数组方式存储数据，查找数据快而插入数据慢，LinkedList使用双向链表实现存储，插入速度较快。
2.List指的是集合.<>是泛型,里面指定了这个集合中存放的是什么数据.
List<String> list=new ArrayList<String>();
<?>是通配符，List<?> 相当于List<Object>.
3.Collection接口定义了存取一组对象的方法，其子接口分别定义了存储方式。Collection是各种集合结构的父接口。
Set：无序且不重复。List：有序且可以重复。
List的有序性表现在输出集合数据的顺序与输入集合数据时的顺序是一致的。
4.List的常用方法：add(),remove(),iterator().
示例代码：
List<String> list=new LinkList<String>();
list.add("a");  list.add("b");  list.add("c");         //在集合中添加元素
Iterator<String> Iterator=list.iterator();           //创建集合的迭代器
while(Iterator.hasNext())   //hasNext()表示还有下一个.
  {System.out.println(Iterator.next());}          //用迭代器遍历list
5.Map集合中的元素是通过key,value（键值对）存储的。
向Map中添加元素，必须用put（）;
Map<String,String> map=new HashMap<String,String>();
map.put("key", "value");        //添加键值对
map.remove("key");