JAVA基础

数据类型

java数据类型包括八种基本数据类型，其中有六种基本数据类型（4个整数型，2个浮点类型），一种字符类型，还有一种布尔类型。

注：低类型自动转换高类型，高类型转换低类型需强制类型转换

byte

• byte数据类型是8位，有符号的。
• 最小值-128，最大值127
• 默认值是0
  

short

• short数据类型是16位
• 默认值是0
  

int

• int数据类型是32位
• 默认值是0
• 一般的整型默认为int
  

long

• long数据类型是64位
• 默认0l
• 主要使用在比较大整数的系统上
  

float

• float数据类型是64位
• 默认值0.0f
• 不能表示比较精确的数字，如货币。
  

double

• double是双精度，64位
• 浮点数默认是double类型
• 默认值0.0d
• 同样不能表示精确的数字，如货币。

boolean

• boolean是数据类型表示一位信息
• 只有两个可取值 true false
• 默认值是false

char

• char类型是一个单一的16位Unicode自符
• 最小值为‘\u0000’，即0
• 最大值为'\uffff'，即65535
• char类型可以存放任何字符
  

引用类型

• 在java中类似于c/c++里面的指针。引用类型指向一个对象，指向对象的变量称为引用变量，这些变量在声明时被指定为一个特定的类型，一旦声明，无法改变。
• 对象、数组都是引用数据类型
• 所有的引用数据类型默认值都是null
• 一个引用变量可以引用任何一个与其兼容的类型

变量类型

java中变量类型包括，局部变量，成员变量，类变量

局部变量

• 局部变量声明在方法，构造方法或者语句块中。
• 局部变量在方法，构造方法或者语句块被执行的时候被创建，当他们执行完之后，变量将会被销毁。
• 访问修饰符不能用于局部变量。
• 局部变量只在声明它的方法、构造方法或者语句块中可见。
• 局部变量是在栈上分配的。
• 局部变量没有默认，所以局部变量被声明后，必须经过初始化才可以使用。

实例

此时的i就是局部变量

public class Demo {
    public void test(){
        int i=0;
        i=i+1;
        System.out.println(i);
    }
    /**
     * 局部变量 i
     * @param args
     */
    public static void main(String[] args) {
        Demo demo=new Demo();
        demo.test();

    }

}

实例变量

• 实例变量声明在一个类中，方法，构造方法，语句块之外。
• 当一个对象被实例化之后，每个变量的值就跟着确定。
• 实例变量在对象被创建的时候创建，在对象被销毁的时候销毁。
• 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息。
• 实力变量可以声明在使用前或着使用后。
• 访问修饰符可以修饰是实例变量。
• 实例变量对于类中的方法，构造方法或者语句块是可见的。一般情况下应把实例变量设为私有。通过访问修饰符可以使实例变量对子类可见。
• 实例变量具有默认值。
• 实例变量可以直接通过变量名访问。

实例

public class Demo02 {
    // 这个变量对子类可见
    public String username;
    //这个变量只对本类可见
    private String password;
    public Demo02(String username) {
        this.username=username;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public void print(){
        System.out.println("username  : " + username );
        System.out.println("password :" + password);
     }
    public static void main(String[] args) {
        Demo02 demo=new Demo02("张三");
        demo.setPassword("1111");
        demo.print();
    }

}

类变量

• 类变量也称为静态变量，在类中以static为关键字声明，但必须在构造方法和语句块之外。
• 无论一个类创建了多少对象，类只拥有类变量的一份拷贝。
• 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。初始化后不可改变。
• 静态变量存储于静态存储区。经常被声明为常量，很少单独使用static声明变量。
• 静态变量程序开始时创建，在程序结束时销毁。
• 与实例变量具有相似的可见性，但为了对类的使用者可见，大多数静态类型变量声明为public类型。
• 默认值和实例变量相似。静态变量可以在静态语句块中初始化。
• 静态变量通过 类名.变量名 访问
• 类变量被声明为public static final时变量名必须使用大写字母，如果不是public final 类型时，其命名方式与
  

实例

public class Employee{

       //salary是静态私有变量

      private static double salary;

      public static final String DEPARTMENT="开发人员";

     public static void main(String []args){

     salary=1000;

     System.out.println(DEPARTMENT+"平均工资"+salary);

     }

}

String类

String类是不可改变的，所以一旦创建了String对象，那它的值就无法改变了，如果需要对字符串进行修改则需要选择使用StringBuffer或者StringBuilder。

关于String的面试问题

String str=new String("abc");

创建了两个String 对象，可以把上面的代码分成String str、=、“abc”、new String()四部分看，String str只是定义了一个名为str的变量，并没有创建对象，=只是对str进行初始化，将某个对象的引用赋值给它，显然也没有创建对象，现在就剩下new String("abc")，即new String()  和 abc;

String str=“abc”；

创建了一个对象；

String str="ab"+"cd";

创建了三个对象；

在JVM中存在一个字符串池，其中保存着许多String对象，并且可以被共享使用，因此他提高了效率。由于String类是final的它的值一经创建不可改变，因此不用担心String对象共享带来的程序混乱。比如：String str="abc",这行代码被执行的时候java虚拟机会在字符串池中查找是否已经存在“abc”这个对象，它的判断依据是String类的equals（object obj）方法的返回值，如果有则创建新的对象，直接返回对象的引用，如果没有则先创建这个对象，然后把它加入到字符串池中，再将它返回。

对于引号包含文本创建String对象已提高效率这种方式效率最高。

StringBuffer类和StringBuilder类

当字符串进行修改时需要使用StringBuffer和StringBuilder类。

和String类不同的是StringBuffer和StringBuilder类的对象能够被多次修改，并且不产生新的对象。

StringBuilder类在java5中提出，它和StringBuffer之间的最大不同之处在于StringBuilder的方法不是线程安全的（不能同步访问）。

由于StringBuilder相较于StringBuffer有速度优势，所以多数情况下建议使用StringBuilder类。如果要求线程安全的情况下则必须使用StringBuffer类。

Java正则表达式

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑、处理文本。

正则表达式不仅限于某一种语言，但是在每种语言中有细微的差别。

正则表达是一个简单的例子，匹配  cat 出现的次数

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Demo03 {
    private static final String REGEX="\\bcat\\b";  // \b匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
    private static final String INPUT="cat cat cattie cat";
    public static void main(String[] args) {
        Pattern p=Pattern.compile(REGEX);
        Matcher m=p.matcher(INPUT);
        int count=0;
        while(m.find()){
            count++;
        }
        System.out.println(count);    
    }

}

构造方法

当一个对象被创建时候，构造方法用来初始化该对象，构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实力变量赋值，或者执行其他必要的步骤来完成对象的创建。

不管你是否自定义构造方法，所有类都有构造方法，因为java自动提供一个默认构造方法，他把所有成员初始化为0。

一旦你定义自己的构造方法，默认构造方法就会失效。

Java流、文件和IO

Java.io包几乎包含了所有操作输入、输出需要的类。所有这些流代表了输入源和输出目标。

Java.io包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向目标写数据。

Java为I/O提供了强大而灵活的支持，使其广泛的应用到网络编程和文件传输中。

读写文件

FileInputStream

该流用于从文件读取数据，他的对象可以用关键字new创建。

有多种构造方法可以用来创建对象。

可以使用字符串类型的文件名来创建一个输入流对象来读文件。

InputStream f =new FileInputStream("d://aaa.txt");

也可以使用一个文件对象创建一个输入流对象读取文件，我们先使用File()方法来创建一个文件对象。

File f=new File("d：//aaa.txt");

InputStream f=new FileInputStream(f);

Java异常处理

异常是指程序中的错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

Exception类的层次

所有的异常类是从java.lang.Exception类继承的子类。

Exception类是Throwable类的子类，除了Exception类外，Throwable还有一个子类Error。

Java程序通常不捕获错误。错误一般发生严重故障时，他们在Java程序处理的范围之外。

Exception有两个子类：IOException和RuntimeException类

关于try..catch..finally的面试问题

public class Test{

      public static void main(String []args){

           Test t=new Test();

           int a=t.get();

          System.out.println(a);

     }

     public int get(){

        try{return 1;}

        finally{return 2;}

    }

}

输出结果是2          注 finally代码块在try之后执行

final finally finalize的区别

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是处理语句结构的一部分，表示总是执行。

finalize是Object的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供的垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。

Java继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。

在Java中，类的继承是单一继承，也就是说一个子类只能有一个父类。

Java的重写和重载

重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。

重写的好处在于子类可以根据需要，定义自己特定的行为。

也就是子类根据需要实现父类的方法。

方法重写的规则

• 参数列表必须完全与被重写方法的相同；
• 返回值类型必须与被重写方法的返回类型相同；
• 访问权限不能比被重写的方法的访问权限更低。
• 父类的成员方法只能被他的子类重写；
• 声明final的方法不能被重写；
• 声明为static的方法不能被重写，但能再次被声明；
• 子类和父类在同一包中，子类可以重写父类的所有方法，声明为final和private的除外；
• 子类和父类不再同一包中，那么子类只能重写父类声明的public和protected的非final方法；
• 重写的方法不能抛出比被重写方法更宽泛的异常
• 构造方法不能重写
• 如果不能继承一个方法，则不能重写该方法
  

重载

重载是在一个类里面，方法名相同，而参数不同，返回类型可以相同，也可以不同。

每个重载的方法都必须有独一无二的参数类型列表。

只能重载构造函数。

重载规则

• 被重载的方法必须改变参数列表
• 被重载的方法可以改变返回类型
• 被重载的方法可以修改访问修饰符
• 被重载的方法可以声明新的或者更广的异常
• 方法能在同一个类中或者在一个子类中被重载

Java多态

多态是同一个行为具有多个不同的表现形式或者形态的能力。

多态存在的三个必要条件：

• 继承
• 重写
• 父类引用子类对象

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误，如果有，再去调用子类的同名方法，

多态的好处：可以使程序有良好的扩展，并可以对多有类的对象进行通用处理。

抽象类

在面向对象的概念中，所有的对象都是通过类来描述的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描述一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其他功能依然存在，成员变量，成员方法和构造方法的访问形式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承才能被使用。

抽象方法

如果你想设计一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

abstract关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

声明抽象方法会造成以下两个结果：

• 如果一个类包含抽象方法，那么该类必须是抽象类。
• 任何子类必须重写父类的抽象方法，或者自身声明为抽象类。最终，必须有子类实现抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。
  

public abstract class Demo04 {
    private String name;
    public abstract void get();

}

public class Demo05 extends Demo04{
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo04 d=new Demo05();
        d.get();
    }
    @Override
    public void get() {
        System.out.println("111111");
        
    }

}

接口

接口，在java编程语言中是一个抽象模型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式实现接口中的抽象方法。

接口并不是类，编写接口的方式和类很类似，但是他们属于不同的概念，类描述对象的属性和方法，接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中所有的方法。

接口无法被实例化，但是可以被实现。一个类实现接口的类，必须实现接口中所有的方法，否则必须声明为抽象类，另外，在java中，接口类型可以用来声明一个变量，他们可以成为一个空指针，或者被绑定在一个以此接口实现的对象。

接口与类的相似点：

• 一个接口可以有多个方法；
• 接口文件保存在.java结尾的文件中，文件名实用接口名；
• 接口的字节码文件保存在.class结尾的文件中；
• 接口相应的字节码文件必须在包名称相匹配的目录结构中。
  

接口与类的区别

• 接口不能实例化对象
• 接口没有构造方法
• 接口中所有的方法否是抽象方法
• 接口不能包含成员变量，除了static和final变量
• 接口不是被继承而是被实现
• 接口支持多继承。

接口有以下特性

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键词
• 每个接口中的方法也是隐式抽象的，声明是同样不需要使用关键字
• 接口中的方法都是共有的。