Java基础知识-笔记一

什么是Java？

一种面向对象的跨平台编程语言，由sun公司推出的。 c语言（面向过程编程的语言）

什么是对象？

宏观上讲的话： 万物皆对象，什么东西都可以当做是对象嘛。

微观上讲的话：对象可以表示成具体的事物，也可以是想象的东西。比如说我们要研究机器人，我们就可以把它当做一个对象，然后就可以对它面向对象编程。

面向对象的三大特征？

1.封装：对外提供公共接口，属性私有化，这就是封装。

2.继承：子类继承父类，会具有父类的特性，Java是单继承的。

3.多态：同一个事件或者说同一个类发生在不同的对象上会产生不同的结果。这叫多态

Java实现多态的机制？

子类重写父类的方法，就是多态的表现。

比如鸟会飞，飞机也会飞，通过写一个飞行的接口，然后可以让鸟和飞机，都实现这个接口，这就达到了扩展性。也是多态的表现。

&与&&区别？

&和&&都是逻辑运算符，表达式2边结果为true时，整个运算结果就为true，否则就是false；

不同的是&&运算符的前面一个表达式为false时，就不会再去判断和计算后面的表达式了。

列如： if(A!=null && A.equals(" ")){ } 如果变量A为null，则不会去执行第二个表达式了，所以也不会引发空指向异常。换成&则会。

| 和 || 区别?

 | 2边都运算。

||: 短路或，如果左边为true,那么右边不参与运算。

分别说下 final ，finaly ，finalize ？

1. final： 用于属性，方法，类。 分别表示属性不可变，方法不能覆盖，类不可继承。

2. finaly： 异常处理语句，try cash 里面的一部分，表示一定会执行，主要用来释放资源。

3. finalize： Object类的一个方法，垃圾回收器执行的时候会调用此方法。

使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

是否可以从一个 static 方法内部发出对非 static 方法的调用？

不可以。因为非 static 方法是要与对象关联在一起的，必须创建对象后，才可以在该对象上进行方法调用，

而 static 方法调用时不需要创建对象，可以直接调用。普通方法可以调用static方法。

String s="Hello" 和 String s=new String("Hello")的区别？

1. String s="Hello" ,它在创建对象时，会先去查找内存中是否有"Hello"的对象，如果有直接用，没有就会创建新的对象。

2. String s=new String("Hello") 不会到内存中查找而是直接创建对象。

short s=1; s=s+1; 有什么错， short s=1; s+=1;呢？

1.会报强制类型转换错误。因为s=s+1 运算时 一个为int 类型， 一个是shor类型。

2.没有错，+= 是java中规定的运算符，所以java编译器会进行特殊处理。

"=="和 equals 方法究竟有什么区别？

Equals ： 只判断值内容是否相等

       = =：如果判断值类型的话，判断内容是否相同。如果判断引用类型则是判断内存地址是否相同

列子：         String a= new String("c")              String b=new String("c")

1.  a==b  结果为false  ；  因为 new  String（"c"） 不会到内存中查找而是直接创建新的对象，所以地址也就不一样了

2.  a.equals(b)  结果为 true ;  因为它们比较的是 内容 。内容都为"c"。

Integer 与 int 的区别

int 是基本数据类型，而Integer是int的封装类

Integer 是引用类型,默认值是null。而int是是值类型默认值是0

* 所以平时我们工作中一般都是用 Integer 作为整数数据类型。因为有些时候有些数值可能是为null ，如果这时候用int 则会报java.lang.Error错。

Math方法： 
     Math.ceil(2,4);//3取比值大的最小整数
     Math.floor(2,5) //区比值小的最大整数

      Math.round  //四舍五入

Date方法： 属于java.util. 而不是java.sql
SimpleDateFormat类：改变时间的格式
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date date=new Date();
String time=sdf.format(date); //将日期格式转换成字符串
Date date2=new Date();
date2=sdf.parse(time); //将字符串转换成日期
System.currentTimeMillis();通常用于循环运算的时间
                        long startTime = System.currentTimeMillis();
                        for(){}
                        longendTime = System.currentTimeMillis();
                        longtime = endTime- startTime//计算出运算的时间
GregorianCalendar单独获取年、月、日
GregorianCalendar gc =new GregorianCalendar(2017,3,5);
System.out.println(gc.get(Calendar.MONTH));

自定义注解：

JDK1.5之后：新增注解，泛型，并发包
注解： 可以理解为插件。
注解分类： 内置注解（元注解，jdk自带的注解） ，自定义注解（spring框架）

内置注解：
@Override  重写父类的注解 检查
@Deprecated  标识过时的 单词都会被划上一条横线
@SuppressWarnings("all") 当某个代码变黄色的时候是警告的意思，而次注解是去除所有警告

重载与重写区别？

重载是同一个类中，方法名称相同， 但是参数或个数不同。与返回值没有关系。

重写是在多个类中， 产生继承关系。父类与子类的方法方法必须相同。

接口与抽象类的区别？

区别:定义接口的关键字是：interface 而定义抽象类的关键字是：abstract。

接口中成员不能有私有， 抽象类可以。

接口中定义的成员， 是finl public static 类型，抽象类没有。

接口中的不能有普通方法，比如说不能有私有的方法。 抽象类中可以。

相同： 

两个都不new

但是 接口与抽象类是面向对象必备知识，设计模式、重构代码有必然作用

异常：java.lang.Throwable 

Throwable: 可抛出的。
Error : 错误，一般情况下需要对程序进行修正
Exception： 异常，可以有针对性的处理方式，如抛出异常，
throw与throws 区别
throws： 用来声明一个方法可能抛出的所有异常信息，只讲异常声明不处理，而是往上传，谁调用就给谁。
throw 用于抛出异常对象

处理异常： 要么抛出异常 throws 异常类， 要么 try catch 捕捉
定义异常处理时，什么时候定义try，什么时候定义throws？
内部如果出现异常，内部可以处理，就用try，不能处理就声明出来，让调用的者来处理
常见的运行异常： ClassCastException(类型转换异常)，NullPointerException(空指向异常)

this：

this: 代表对象。就是所在函数所属对象的引用。哪个对象调用this 就代表哪个对象

this.  表示调用该对象属性和方法。  this() 表示调用本类中对应参数的构造函数 

注意： 用this 调用构造函数，必须定义在构造函数的第一行。

String ，StringBuffer ,StringBuilder 有什么区别

String 字符串常量 。String是不可变字符，一旦分配了内存，此内存的值将不会改变，又将String赋值是，会重新分配一块内存，创建新的对象。

StringBuffer 字符串变量（线程安全） 创建字符串之后可以直接更改，避免了过多的对象创建，而导致的内存泄漏。

StringBuilder 字符串变量（非线程安全） 

列如：  String("abc").equals(new String("abc"))                运行结果为true

     StringBuffer("abc").euqals(new String("abc"))     运行结果为false

导致原因：是因为String实现了equals 方法，而Stringbuffer 则没有。

所有的类都继承于object类， Object 有哪些方法？

1．clone方法

保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

2．getClass方法

final方法，获得运行时类型。

3．toString方法

该方法用得比较多，一般子类都有覆盖。

4．finalize方法

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

5．equals方法

该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。

JDK 语言包： 常用的包： java.lang   , java.util ,  java.io   , java.sql  

注意 ： java.lang包是java内置的一个基础包。默认情况下每个Java程序都会自动导入该包

数组有没有length()这个方法? String有没有length()这个方法？

答：数组没有length()这个方法，有length的属性。String有有length()这个方法。

hashCode方法

该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

一般必须满足obj1.equals(obj2)==true。可以推出obj1.hashCode()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。

wait方法

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生。

（1）其他线程调用了该对象的notify方法。

（2）其他线程调用了该对象的notifyAll方法。

（3）其他线程调用了interrupt中断该线程。

（4）时间间隔到了。

此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

notify方法

该方法唤醒在该对象上等待的某个线程。

notifyAll方法

该方法唤醒在该对象上等待的所有线程

什么是反射？

对于反射的话，我的理解就是对一个未知类的一个反向编译。在未知类的情况下使用，他都是在类加载的时候再去得到类的完整信息，如的属性，构造方法等。
它的基本步骤就是，获得Class对象然后实例化，再去获得类的属性，方法构造函数，之后访问他，

而获取Class对象有三种方式，1.有Class.forName("类名全称")， 2. 对象.getClass()      3.  某个类.class;

反射的优缺点？

优点：java的反射机制就是增加程序的灵活性、

缺点：（1）性能问题：使用反射基本上是一种解释操作，

用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用。

（2）使用反射会模糊程序内内部逻辑：程序员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。

那些地方用到了反射？

例如: jdbc、Java常用框架、jdk的动态代理、android的加载布局文件

Java.IO包简介
    java.io包是java内置的包，包含一些对文件，目录的属性进行操作，读写的类。
    声明语法：  import java.io.*;

File类：
当前目录创建对象： File f1 = new File("aaa.txt");
指定目录创建对象： File f2 = new File("D:\\Java\\hello.java"); *注意双斜线
常用方法：
boolean mark = f1.createNewFile();  //创建文件方法
boolean mark = f1.exists();         //是否为文件
boolean mark = f1.isDirectory();    //是否为目录
boolean mark = f1.getName();        //文件名称
boolean mark = f1.getAbsolutePath(); //文件绝对路径
boolean mark = f1.length();          //文件内容的字节
boolean mark = f1.delete();          //文件内容的字节
File[]  fs   = f2.listFiles();          //返回文件夹内的子文件，子文件夹的数组
 Stream(流) 接收和发送数据信号的通道
流动方向： 输入流    输出流
传输格式： 字节流    字符流
字节流： 8位通用字节流，以字节为单位，继承流 InputStream（输入字节）和 OutputStream（输出字节流）
字符流： 16位Unicode字符流，以字符位单位， 适合处理字符串和文本，继承与 Reader(读取流) 和 writer （写入流）类。
FileInputStream类为文件输入流，继承InputStream类。用于读取文件
File file = new File("aaa.txt");
FileInputStream f1=new FileInputStream(file); //读取文件内容
for(int i=0;i<file.length(); i++){
   char c=(char) f1.read();
   System.out.println(c);
}
System.out.println();
f1.close(); //关闭流
FileOutputStream类为文件输出流，继承于OutputStream类，用于写文件内容。
String str="Hello word";
//创建文件对象
File file=new File("ccc.txt");
//创建输出流  附加第二个参数为true则会在指定性文件后追加，默认不追加
FileOutputStream f=new FileOutputStream(file,true);
for(int i=0; i<str.length();i++){
f.write(str.charAt(i));
}
f.close();
拷贝文件代码列：
  public static void main(String[] args) throws IOException {

File f1=new File("szf1.txt");
File f2=new File("szf2.txt");

if(!f2.exists()){
f2.createNewFile();
}
FileInputStream input=new FileInputStream(f1);
FileOutputStream ouput=new FileOutputStream(f2);

byte[] buf=new byte[1024]; //创建字节数组作为缓冲区
System.out.println("开始复制文件");

while(input.read(buf)!=-1){
ouput.write(buf);
}
System.out.println("文件复制成功");
input.close(); //关闭流
ouput.close();
}
字符流：涉及4个类  FileReader , FileWriter, BufferedReader, BufferedWriter ,BufferedReader, BufferedWriter为字符流提供缓冲区，提高效率。
        读：
FileReader fr=new FileReader("szf2.txt");
BufferedReader br=new BufferedReader(fr); //字符缓冲区
       String str=null;
       while((str=br.readLine())!=null){
   System.out.println(str);
       }
br.close();

fr.close();

         写：
File file=new File("szf3.txt");
FileWriter fw=new FileWriter(file);
BufferedWriter bw=new BufferedWriter(fw);

bw.write("大家好，我叫小明");
bw.write("我正在努力");
bw.newLine(); //换行
bw.write("再见！！！");

bw.close();
fw.close();


基本数据类型读/写：
FileInputStream 和 FileOutputStream 在读写是不考虑数据类型；
FileWriter 和 FileReader 在读写时，将所有数据都看做字符。
DataInputStream 和 DataOutputStream 可以将各种类型数据写入和读取，但是不能单独使用。

    写：
File file=new File("szf4.txt");
FileOutputStream fo=new FileOutputStream(file);
DataOutputStream do=new DataOutputStream(fo);

do.writeBollean(true);
do.write(1001);
do.writeUTF("你好 java");
do.writeDouble(10.23);

fo.close();
do.close();

    读：
FileInputStream fi=new FileInputStream(file);
DataInputStream di=new DataInputStream(fi);
bollean  a=di.readBollean();
int b=di.read();

Double c=di.readDouble();

温馨提示：以上内容只是个人觉得重要的部分，所以只供参考。