java基础

一：静态方法只能调用静态成员变量或者静态方法。
：面向对象：即将事情分为对象来做，每个对象要实现哪些功能。比面向过程好一点。
swtich(变量){
case 常量1 :
语句；
break；
case 常量2：
语句；
break；
.
.
.
.
default：（case没有符合的常量值相当于else）
语句；
break；
}

Continue：结束当前本次循环，直接进入下一次循环，即当前本次循环没有输出。（只能用于循环语句）

break：结束当前循环体。例如双重循环体中内层循环有break就结束内层循环，不结束外层循环。（用于switch和循环语句中）

return：结束整个循环体，包括多重循环，只要出现return关键字就结束整个循环体。

=是赋值运算符，==相等于运算符。

类型转换 ：int a=2； short b=3 。小范围类型可以直接向大范围转换（小范围可以赋值给大范围的类型）（可以 a=b），
而大范围不能向小范围转换，需要转换类型（b=（short）a），将a转换为short类型。

二：同一个类中，方法可以直接调用 ，不用 （对象.方法） 调用，直接（方法（））调用。

三：this的使用 ：1.当形参与成员变量重名时，如果在方法内部要使用成员变量，必须添加this来表明该变量是成员变量 。
2.在任意方法内，如果使用当前类的成员变量或者成员方法，必须在其前面添加this，增加代码阅读性。
3.方法构造器（构造方法）中，this（）必须放在首行，即在构造方法中this()调用没有参数的构造方法，
this(a)调用一个参数的构造方法........，this调用本类其他构造方法，不能自己直接或间接调用自己的构造方法。

四：JavaBean：是java的组件之一，即使用JavaBean的话可以自动生成成员变量的set和get方法，不用自己一个一个写。
如何使用：代码中鼠标右键 source ，setter and getter。。

五： private：本类。
Protected：本类，子类，本包。
Public ：在本类，本包，子类，任何地方都可以使用。
default（默认）：本类，本包。

六：java只有单层继承，不能多继承，即只能extends一个父类，继承父类成员变量和方法。

七：继承中方法重写的好处，重写适用于多态，创建不同对象时，便于使用不同作用的重写方法。 重写快捷键（在要重写的地方 alt键加/）。且重写的方法限制范围不能比父类的限制范围小。

八：super的使用： 1.使用super，子类可以调用父类的所有层级，访问父类的属性，方法，和构造器。子类所有构造器默认都会访问父类中的空参数构造器，父类没有空构造器时，
子类用super调用父类相应的构造器，基本是赋值过程。
2.子类用构造器直接赋值时，需要通过super调用父类的构造器给继承的属性赋值。eg. 父类 :int age ,int score; 子类 string gender; 子类要给age 和score，gender赋值需要构造
3.(int age,int score，String gender),且super调用父类对应的(int age,int score)构造器。
即是，子类要给哪个继承的属性赋值就调用父类对应的构造器。

九：多态（继承，且含有重写）： 1.编译时：如果变量类型是父类，引用对象是子类，那么该变量不能访问子类的属性。即变量只能访问对应类型的属性。
eg：Student extends person，person p1=new student();
那么 p1只能访问person中的属性和方法（重写方法除外），不能访问student的属性。(原因:属性在编译时确定，编译时 P1为person类型，没有student的属性)。
2.运行时：调用的方法是new类型的方法。 eg ：Student extends person，person p1=new student， P1.方法调用的是 student的重写方法。如果子类没重写，那么就调用父类的。
总结：属性看类型（栈），重写方法看对象（堆）。
十：instancof 判断对象是否属于某个类 （对象 instanceof 类） ， 返回值为Boolean类型。 一般用于检测某个对象是否为类的子类。 子类的对象也属于父类。

十一：Object类。所有Java类的根父类，在继承中处与最高级的类。 向方法设置形参时，可以确定形参时一个类的对象，但不知道具体是哪个类，可以用Object obj（对象）当形参。调用方法时传递实参就行了。
主要方法：equals（） ，对象比较 ，判断两个对象的值是否一样，a .equals (b) 返回值为Boolean。
hashcode（），取得哈希码。
toString(),显示地址。 打印对象地址， a.toString()

十二：数据类型转换。 1.自动转换。小类型可以直接转化为大类型。eg: int i=1; long l =int i;
2.强制转换。大类型强制转化为小类型。 eg：long l = 1001; int i=(int ) l;
java对象转换。 student extends person.
1.自动转换。子类到父类的类型转换可以自动进行。 eg: student s=new student(); person p=s;(相当于person p =new student（）多态)。
2.强制转换。父类到子类转换必须通过强制转换进行。 eg：person p=new person; student s=(student)p; 当方法形参是（person e）时，此时在该方法中只能调用person 的方法，
如果传入的实参是 student的对象，那么需要经过instanceof 判断是否为student对象，然后new 一个新的student实参，强制将传入实参转化为student 并赋给新的实参，
通过新的实参调用student方法。
3.非法转换。 无继承关系的转换是非法的，只有继承才可以相互转换。

十三：==与equals。 1.基本数据类型，如string file Date ，==比较的是对象（对象地址，堆中的地址），equals比较的是内容。 其他类，==和equals都是比较对象地址。 equals方法可以重写。
==比较地址，equals比较内容。

十四：toString（）。 输出当前对象内存地址，可重写。

十五：代码块。 java执行顺序是先执行成员变量，然后代码块，最后是构造器。静态代码块，只能使用静态方法与属性。在程序运行中，每次new新的对象，静态代码块只执行一次，非静态每次都要执行。
静态代码块用的较多，来处理静态属性。

十六：final 最终关键词， 被final修饰后不能进行任何的修改，比如 final类不能被继承，方法不能被重写等， static final 修饰的常量是全局常量。

0十七：抽象类。抽象类不能实例化，是作为父类被继承的，子类必须重写父类的抽象方法，若没有重写全部的抽象方法（只要有一个抽象方法），仍为抽象类。抽象类可以有构造器，有方法体。 可以没有抽象方法。

十八：接口。一种特殊的抽象类，一个类可以实现多个接口（A implements B，C，D，..），接口可以继承其他接口。 所有成员变量默认由public stataic final 修饰（全局常量），方法由 public abstract修饰。
实现接口的类必须实现接口中所有具体方法，否则为抽象类。 接口的多态：A a1= new B(); a1只能使用接口A的方法，不能使用B的方法。

十九：内部类（A外部类，B内部类）。可以声明为private和protect,static 等外部类的成员变量内部类也可以使用，内部类可以给外部类变量赋值，A.this.变量赋值。 外部类要用自己内部类的方法，
需要在外部类中的方法new一个内部类对象s，然后调用，

二十：面向对象（类）的五大属性，成员变量，成员方法，构造器，代码块，内部类。

二十一：异常（error/exception）。 exception：1.数组越界异常：Arrayindexoutof... 2.空指针异常：nullpointer.... 。 1.捕获异常：try{异常的代码} catch(Exception e){}当不知到捕获的是什么类型异常，可以用
异常的父类Exception。 try找出异常，catch捕获异常，进行处理（getMessage(),得到异常信息，printStackTrace()跟踪异常的堆栈内容）。异常的代码被抛出后，后面的代码就不执行了。
二.抛出异常，throws Exception 加在方法后面，如果方法内容有异常就抛出， 调用该方法时用try catch语句捕获异常。
三：子类继承父类，子类重写父类抛出异常的方法时，不能比父类抛出异常的范围大。
try{}cath{}finally{} 不管有没有异常抛出都要执行finally的语句。 finally中不要return。否则会影响结果。

二十二：集合：迭代器遍历集合 Iterator it =a.Iterator() [a为待遍历的集合]，while(it.hasNext()){syso}。 for each 遍历：for（Object obj：a）{.syso.}[ 把集合a的值取出来赋值给 obj]。主要遍历集合。

二十三：泛型(Gneric)：想要在集合list1中只添加某一属性类型的数据。eg(String 类型)list <String>list1 =new Arraylist<String>(); 此时只能 lsit1.add("String类型的数据")。关键字<>。
1.泛型类：(class A(Type),A 为Type类型的类(任意类型)) 。 在new A的对象是用泛型关键字定义Type为何种类型。如果不指定Type类型，则默认是Object类型。eg:
A<String> a1=new A<String>();[Type -String]。 A a2 =new A()[Type -Object]。
可以有泛型类型的成员属性，但没有静态的泛型类型成员属性，所以静态方法只能自己定义泛型来用泛型属性。 eg： 有Type t; 没有 static Type t.
2.泛型接口：interface B<T>{public T test(T t1);} class A implements B<String>{@Override public String Test(String t1)}[这是类在实现接口时定义接口类型]
interface B<T>{public T test(T t1);} class A<T> implements B<T>{@Override public T Test(T t1)}[这是没有定义接口泛型]。
如果类在实现接口时没有定义接口泛型，那么类也有添加同样的泛型，并重写接口的方法，此时就是泛型类了，用new对象时定义泛型。
如果类在实现接口时定义了泛型，那么类直接重写，并正常创建对象调用方法，不用在定义泛型类型。
3.泛型方法：在类型前面加泛型<T>，调用之前形参没有固定泛型类型的话，调用时，传入的参数是什么类型，泛型就是什么类型。
4.泛型通配符(方法里用)：方法里需要一个集合的参数，不确定该集合到底存什么数据就用<?>。eg: void test(List<?> list){}[list集合中<?>通配符不知道传入什么类型]，在实例化对象时，调用该方法。
void test(<?> extends A){}[该方法只允许泛型为A及其子类调用]（无穷小-A）。 <?> super A [泛型为A及其父类调用]（A-无穷大）。 <? extends Comparable>,泛型为实现该接口的类调用。

二十四：枚举类（enum）：enum 类名{} eg :ECLIPSE packge learning -enum1。

二十五：注解：@Override 重写， @Deprecated 过时 ，@SuppressWarning 抑制编译器警告。

二十六：IO流： 文件流(数据流的读写基于文件的操作，速度慢)：FileInputStream ,FileoutputStream------字节流，byte[]存放临时数据 ,FileReader,FileWriter------字符流，char[]存放临时数据。
缓冲流(数据流的读写基于内存的操作，速度快)：BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter5.
转换流：InputStreamReader,OutputStreamWriter.
随机存取文件流：RandomAccessFile。(可以自定义读取或插入某行数据)

File类只能操作文件本身，不能操作文件的内容（File f1=new File("文件路径")） 即将该文件复制给f1. 访问文件需要输入/输出流。

访问文件名：1：f1.getName(); 获取文件名称 。2：f1.getName(); 获取文件名称。3：getParent();返回父级路径。
4：renameTo(); 对文件重命名 --eg： f1.renameTo(new File("文件路径"))，在路径里把文件名改了就行。5.getAbsolutePath();返回用相对路径创建对象的，该文件的绝对路径。
5.getAbsoluteFile(); 返回用相对路径创建的对象的绝对路径 。 大多数与文件的绝对路径一样。
文件检测： 1.exits();检测文件是否存在，返回值为Boolean。 2.canWrite(); canRead(); 检测文件是否可读可写，返回值为Boolean。3.isFile();检测当前对象是否是文件，Boolean。
4.Length(); 返回文件的字节大小。
文件操作： 1.createNewFile();创建新的文件---eg: File f=new File("路径"), f.exists();判断当前文件是否存在，不存在的话 f.createNewFile();创建该文件。
2.delete(); 删除文件--f.delete();
3.mkdir();创建单层目录--eg：File f=new File("路径")，f.exists(); f.mkdir(); 。 mkdirs():创建多层级目录--eg：File f=new File("路径")，f.exists(); f.mkdirs();
4.list(); 获取当前对象下的目录与文件--eg：File f=new File("路径")，String []s =f.list();将数组list的值赋值给S，遍历s-- for(String s1:s){syso(s)}。
5. listFiles();返回当前对象下的目录与文件的绝对路径。 File [] ff=f.listFile(); 将listFile赋给File类型的ff ，遍历 ff--for()遍历。

字节文件流：1. FileInputSream，读取文件内容， FileOutputStream，写入文件 ，复制文件 ........... ---------------------具体内容 ：ECLIPSE packge learning -IO2 。
2.文件字节流很通用，可以用来操作字符的文档，还可以操作任何的其他类型文件(图片，压缩包等)。因为字节流使用的是二进制。
字符文件流：1.FileReader ，读取文件内容， FileWriter，写入文件 (不用char数组存数据)， 复制文件-------- 都与字节流操作相同。
写入文件时，如果目录下有同名的文件，内容将被覆盖。 读取文件必须保证文件存在，否则异常。

字节缓冲流：BufferedInputStream ,读取文件内容(eclipse里的文件). BufferedOutputStream,写入文件(写入eclipse). 复制文件......
-----先要创建一个字节文件流的对象(读取/写入),然后将该对象放进缓冲字节流的对象当中(读取/写入)，然后后续操作与字节流一样。
字符缓冲流：BufferedReader,读取字符文件. BufferedWriter,写入字符文件. 复制文件................... 读取和写入操作都与字节缓冲流一样，创建对象存入对象，然后操作。

总结：读取文件(文件/缓冲字节流)--1.创建流对象。2.创建一个byte数组用于接收文件数据。3.设置起始读取文件的长度int len=0。 4.while((len=流对象.read(byte))!=-1)将数组的长度赋给len()，
并判断是否=-1，输出new String(byte,0,len)。 5.关闭流
(文件/缓冲字符流)--...................。2.创建一个char数组用于接收文件数据。3..............................................................。4..........................................................................................。5..............................。

content---待写入的内容
写入文件(文件/缓冲字节流)--1.创建流对象。2.流对象.write(content.getBytes(content))；--将内容写入内存中。3.流对象.flush(); --将内容存入硬盘。4. 关闭流

（文件/缓冲字符流) --1..................。2...................................................................................................。3.............................................................4.....................

读取文件创建数据，并用new String（）输出数据 。 写入文件不用创建数组，直接用getBytes方法将内容存到内存，在flush方法存入硬盘。

文件流是对计算机的硬盘操作，缓冲流是对eclipse里的文件操作。

转换流(当字节流中的数据都是字符的时候使用)：InputStreamReader---字节流转字符流读取文件。 OutputStreamWriter-----字节流转字符流写入文件。 eg:ECLIPSE--learning--IO7.

二十七：标准打印流

二十八：对象流：1.对象序列化(实现Serialize接口)ObjectOutputStream类----对象转化为二进制。 2.反序列化(实现Deserialize接口)ObjectInputStream----将二进制流转换为Java对象。。
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("路径"))---- out.WriteObject(对象名)。----out.flush();
ObjectInputStream in =new ObjectInputStream(new FileInputStream("路径")) --------- Object obj=in.readObject()---- 强转Object为对象类---输出对象。

二十九：随机存取流：RandomAccessFile. 1. 随机读文件--创建一个RandomAccessFile对象，该对象有两个参数，第一个为path，第二个为对文件进行什么操作. 2.seek(x) x为操作的位置。。。。
eg：----ECLIPSE packge learning -IO11。

三十：反射：获取方式：class s=类名.class ，class s=对象.class ， class s=class.forname("包名.类名")----常用。 Class clazz = Class.forname("包名.类名")
反射创建对象: clazz.new999Instance();
Class superClass=clazz.getsuperclass();--获取父类， Class interfaceClass =clazz.getInterface(s)(); 获取接口类， getName（）返回对应类名。
基本就是用一个Class对象接收要获取的类对象，然后用Class对象访问各种属性。
getConstructors(),返回public 的构造方法--- getModifiers(),返回构造方法修饰符，数字-------getDeclaredConstructors()----返回所有的构造方法------getParameterTypes()----获取构造方法参数类型

getClass();------如果没有重写getClass方法，那么执行的是object类的getclass方法，返回当前运行类的名字。
eg:---classs/test1 ---------好难好多

三十一：线程（一般用接口的方式）：代码之间的运行是独立的。实现方式1.继承Thread类，重写run（）方法，方法里放线程的代码--------，然后在main方法里用(多态创建对象)对象.start（）方法开启线程。
eg: A extends Thread{void run(){}} ------- Thread t1 =new A(); t1.start;

2.实现Runnable接口，实现(重写)run（）方法，方法里放线程的代码---------------，然后在main方法里实例化一个Thread的对象，向对象中传入线程的类对象。
eg: A implements Runnable{void run(){}}-------- Thread t1=new Thread (new A(),"线程名称"),如果不写线程名称的话，默认为Tread-1/2..........。
t1.stName(); 设置线程的名称 --t1.getName（）；返回线程名称--(String)。 t1.setPriority(x)--设置线程优先级0-10。 t1.getPriority()--返回优先级
优先级越大，线程更大概率被执行。 Thread.yield()线程让步，Thread.sleep(时间数)---线程睡眠时间

线程的生命周期：新建(Tread对象)--就绪(start())--运行(执行run())--阻塞(run()含有yield())--死亡(自然/强制stop())
方法关键字：synchronized -----------同步锁，锁整个对象，不同的对象，不同的锁。 静态方法的同步锁是锁所有对象。可以锁整个方法和代码块。 synchronized(this){代码}---锁代码块--当前对象。
wait()----线程挂起 。 notify()------线程唤醒 。 notifyall()----唤醒所有线程。 只能用在synchronized锁的代码块或者方法中。

 

三十二：集合。
Set接口，继承collection。 hashset继承abstractSe t
1.Set： HashSet实现Set接口。 特点: 1.不保证元素的排列顺序。2.不可重复。3.线程不安全。4.元素可以是null。
注意：根据元素的hashcode决定元素的存储顺序。 如果元素的equals相同，但是hashcode不同，依旧可以添加该元素。
方法：add()添加元素，remove()删除元素，clear()清空集合，contains()判断元素是否存在。
遍历：Iterator遍历。 for each遍历。
2.TreeSet：对存储的单一类型的对象有自然排序的功能，比如整数从小到大，字符串以首字母排序..等等。 如果存储混合的数据比如有整数和字符串等要报错。 存储单一类型的数据。
如果存储某种自定义类型的数据，比如user ，有age，name等属性，需要实现compartor<user>接口,并重写compare方法，做排序比较. >1,<1等等。。。

arraylist继承abstractList ，arraylist如果不设置初始化长度，默认长度是10。
3.List：ArrayList： 方法：add()添加，(根据index添加), remove(index)根据index删除。set(index,value)根据index修改元素，size()获取list大小。addall(index,list)：将一个list插入到另一个list中，根据index插入。
遍历：for each遍历：遍历key值，keyset()，根据key值得到value ,getvalue(key).
hashmap继承AbstractMap
4.Map:HashMap: 方法：put(key,value)添加元素， remove(key)根据key删除元素。。。 get(key)得到对应key的value
遍历：for each遍历 ，先遍历key值， Object key: map.keyset(),根据遍历的key值得到map的value，get(key)

三十三：单例创建(只有一个实例)： 1.饿汉式： 创建一个私有的无参构造方法。 new一个私有的静态的单例对象。 创建一个publci静态的方法，返回该静态单例对象。
2.懒汉式：创建一个私有的无参构造方法。 创建一个私有静态的单例对象==null。 创建一个public静态方法，判断该单例对象是否为null，如果为null，new一个danli对象。
3.枚举类中的枚举创建也是单例的。 每次调用枚举中的值是以对应构造方法的参数个数赋值的。

三十四：syso输出：String与整数 的输出。整数类型没遇到字符串时，以整数相加，遇到字符串就变成字符串相加。
1.System.out.println("String"+4+5);//String45--第一个为字符串所以编译器以字符串相加
2.System.out.println(4+5+"String");// 9String --4，5做加法，遇到字符串做字符串相加。

三十五：++i与i++的区别。 ++i先自增再进行表达式运算，i++是先进行表达式运算再自增。

三十六：&与&&的区别（and）。 &，&&都是两边为true值才为true。 &左边为false后也会进行右边的比对。 &&左边为false后，不进行右边的判断。

三十七：||逻辑或。 or，一边为true值为true。

三十八： 三元运算符 ? 表达式1 :表达式2 。判断x>0，如果为true执行?后的表达式，如果为false执行:后的表达式。（用于两个数比较大小和三个数比较大小）

三十九：二维数组： int[] [] arry=new Int[2][3]{ {1,2,3},{4,5,6}}。 遍历二维数组。 先遍历输出一维的数据，再遍历二维数组的值。
for(int y=0;y<arry3.length;y++) {
int[] arry33=arry3[y];//得到一维数组的值
for(int m=0;m<arry33.length;m++) {//再遍历输出一维数组里的值，即二维数组。
System.out.print(arry33[m]);
}
}
一维数组与二维数组的定义： 一维： int [] a=new int[10]; int b []=new int[10];
二维： int [][] c=new int[5][]; int [][] d=new int[5][2];-----不能int [][] f=new int[][2];------------二维数组必须要定义一维长度，二维长度可定义可不定义。

error和exception：error：jvm运行异常 。 exception：程序出现异常，比如空指针等。
运行时异常和编译时异常， 运行时异常： 1/0 --运行后才会知道异常。 编译异常： 红色波浪线。

String 是一个char数组。
String与byte的相互转换： byte -->String ：【byte [] bs ={ 97, 5,6}; String byte =new String(bs)】。 String -->byte： 【String str="asd"; byte[] bs=str.getbytes();】
八大基本数据类型：byte 8，short 16，long 32，int 64，float 32，double 64，char 8，boolean 16。 基本数据类型+任意字符串=String类型。 他们的封装类都是final类型的 (Inreger,Float,Double,Boolean.....)

try catch finally的返回。 如果try里面有 return 或者catch里面有retrun， finnaly中么有return，那么try/catch里面的return会被放在临时空间里，执行finnaly之后被返回，不会被finally的赋值所改变。
如果finnaly也有return那么直接返回finnaly的值。

 

构造函数没有返回值，

double与float： float类型 赋值时，如果是小数必须加f ，否则是double类型。 eg ：float f=45.0f / float f=45；

String,StringBuilder,StringBuffer的区别：都是final类。运行速度：String<Stringbuffer<StringBuilder。 String 是常量池，一旦创建就会一致存在该常量，更改值会再创建新的常量池对象。
StringBuilder和StringBuffer的对象是变量，可以更改。StringBuilder是线程不安全的，而StringBuffer是线程安全的。
String：适用于少量的字符串操作的情况。StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况。StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

 hashcode相同，equals可能不同， equals相同，hashcode一定相同。