java基础回顾

时间 2019-11-07

标签 java 基础回顾栏目 Java 繁體版

原文原文链接

基本数据类型和引用数据类型的区别

基本数据类型
声明时直接在栈内存中开辟空间，并直接在当前内存中存放数据，赋值时传递的是变量中的值，总的来讲，基本数据类型是传值的。
引用数据类型
会将实际的数据存放在堆内存中，同时，在栈内存中声明一个数组名或对象名，存放着在堆内存中的是地址；
二者关系图
二者对比图
二者建立图
赋值运算符（=）的做用图

值传递和引用传递区别

值传递
在方法的调用过程当中，实参把它的实际值传递给形参，此传递过程就是将实参的值复制一份传递到函数中，这样若是在函数中对该值（形参的值）进行了操做将不会影响实参的值。由于是直接复制，因此这种方式在传递大量数据时，运行效率会特别低下。
引用传递
引用传递弥补了值传递的不足，若是传递的数据量很大，直接复过去的话，会占用大量的内存空间，而引用传递就是将对象的地址值传递过去，函数接收的是原始值的首地址值。在方法的执行过程当中，形参和实参的内容相同，指向同一块内存地址，也就是说操做的其实都是源数据，因此方法的执行将会影响到实际对象。（注意：这里所说的是改变源数据的内容，如：改变的对象的属性）

实例java

public class Example {    
    String str = new String("hello");    
    char[] ch = {'a', 'b'};
    
    public static void main(String[] args) {
        change(str, ch);
        System.out.println(str);    //输出：hello
        System.out.println(ch);    //输出：cd
    }    
        
    public void change(String str, char[] ch) {        
        str = "ok";
        ch[0] = 'c';    //改变数据源内容
    }
}

过程分析图：

经常使用类:java.lang.Enum

使用场景
当咱们须要限制一系列变量的时候，一般想到数组或者集合；其实不少时候咱们须要限定变量须要作的事情不少，或者说若是被限制的变量能够作其余事情的话就更好了，而不是单纯的一个变量，那么，枚举的做用不只仅可让你使用限制在一个enum中的变量，而且这些变量的灵活性和拓展性很好。数据库

public enum WeekEnums {
        //注：枚举写在最前面，不然编译出错
        Sunday,
        Monday,
        Tuesday,
        Wednesday,
        Thursday,
        Friday,
        Saturday;
 
        private static String getWeek(WeekEnums weekEnums) {
            String week = null;
            switch (weekEnums) {
                case Sunday://星期天
                    week = "星期天";
                    //此处写逻辑处理代码
                    
                    break;
                case Monday://星期一
                    week = "星期一";
                    //此处写逻辑处理代码
                    
                    break;
                case Tuesday:// 星期二
                    week = "星期二";
                    //此处写逻辑处理代码
                    
                    break;
                case Wednesday://星期三
                    week = "星期三";
                    //此处写逻辑处理代码
                    
                    break;
                case Thursday:// 星期四
                    week = "星期四";
                    //此处写逻辑处理代码
                    
                    break;
                case Friday://星期五
                    week = "星期五";
                    //此处写逻辑处理代码
                    
                    break;
                case Saturday://  星期六
                    week = "星期六";
                    //此处写逻辑处理代码
                    
                    break;
            }
            return week;
        }
    }
//获取方式：
String weekday = WeekEnums.getWeek(WeekEnums.Friday);

经常使用类：java.math.BigDecimal

使用场景
float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供彻底精确的结果，因此不该该被用于要求精确结果的场合。可是，商业计算每每要求结果精确，这时候就应该使用BigDecimal。

经常使用类：java.lang.ThreadLocal

使用场景
在多线程中，为保证多个线程对共享变量的安全访问，一般会使用synchronized来保证同一时刻只有一个线程对共享变量进行操做。这种状况下能够将类变量放到ThreadLocal类型的对象中，使变量在每一个线程中都有独立拷贝，不会出现一个线程读取变量时而被另外一个线程修改的现象。ThreadLocal是编程中空间换时间的体现。
ThreadLocal的内部结构编程
1. 每一个Thread线程内部都有一个Map。
2. Map里面存储线程本地对象（key）和线程的变量副本（value）。
3. 每一个Thread线程内部都有一个Map。
4. Thread对于不一样的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，造成了副本的隔离，互不干扰。
ThreadLocal的内部结构图

实例数组

//包含业务惟一标识的类
public class Context {
    private String transactionId;
 
    public String getTransactionId() {
        return transactionId;
    }
 
    public void setTransactionId(String transactionId) {
        this.transactionId = transactionId;
    }
 
}

// 其中引用了Context类
public class MyThreadLocal {
    private static final ThreadLocal<Context> userThreadLocal = new ThreadLocal<Context>();
    public static void set(Context user){
        userThreadLocal.set(user);
    }
    public static void unset(){
        userThreadLocal.remove();
    }
    public static Context get(){
        return userThreadLocal.get();
    }
    
}

//ThreadLocalDemo.java。生成并将业务标识设置到ThreadLocal中而后在业务方法中调用
public class ThreadLocalDemo implements Runnable{
    private static AtomicInteger ai = new AtomicInteger(0);
    public void run() {
        Context context = new Context();
        context.setTransactionId(getName());
        MyThreadLocal.set(context);
        System.out.println("request["+Thread.currentThread().getName()+"]:"+context.getTransactionId());
        new BusinessService().businessMethod();
        MyThreadLocal.unset();
    }
    
    private String getName() {
        return ai.getAndIncrement()+"";
    }
 
    public static void main(String[] args) {
        ThreadLocalDemo tld  = new ThreadLocalDemo();
        new Thread(tld).start();
        new Thread(tld).start();
    }
 
}
public class BusinessService {
 
    public void businessMethod() {
        Context context = MyThreadLocal.get();
        System.out.println("service["+Thread.currentThread().getName()+"]:"+context.getTransactionId());
    }
 
}

String

Q1：String s = new String("hollis");定义了几个对象。
A1：若常量池中已经存在”hollis”，则直接引用，也就是此时只会建立一个对象，若是常量池中不存在”hollis”，则先建立后引用，也就是有两个。
Q2：如何理解String的intern方法？
A2：当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，若是有，则返回其的引用，若是没有，则在常量池中增长一个Unicode等于str的字符串并返回它的引用；

实例安全

String s1 = "Hollis";
    String s2 = new String("Hollis");
    String s3 = new String("Hollis").intern();

    System.out.println(s1 == s2);    //输出：false
    System.out.println(s1 == s3);    //输出：true

建立分析图

String s3 = new String("Hollis").intern();，在不调用intern状况，s3指向的是JVM在堆中建立的那个对象的引用的（如图中的s2）。可是当执行了intern方法时，s3将指向字符串常量池中的那个字符串常量。
String不变性
一旦一个string对象在内存(堆)中被建立出来，他就没法被修改。注意：String类的全部方法都没有改变字符串自己的值，都是返回了一个新的对象。若是你须要一个可修改的字符串，应该使用StringBuffer 或者 StringBuilder。不然会有大量时间浪费在垃圾回收上，由于每次试图修改都有新的string对象被建立出来。
实例
定义一个字符串网络
```
String s = "abcd";
```
图解

使用变量来赋值变量数据结构
```
String s2 = s;
```
图解

字符串链接多线程
```
s = s.concat("ef");
```
图解
ide
为何设计成不可变：
设计成不可变的主要目的是为了安全和高效
为何数组有length属性？
首先，数组是一个容器对象，其中包含固定数量的同一类型的值。一旦数组被建立，他的长度就是固定的了。数组的长度能够做为final实例变量的长度。所以，长度能够被视为一个数组的属性。
为何String有length()方法？
String背后的数据结构是一个char数组,因此没有必要来定义一个没必要要的属性（由于该属性在char数值中已经提供了）。和C不一样的是，Java中char的数组并不等于字符串，虽然String的内部机制是char数组实现的。（注：C语言中，并无String类，定义字符串一般使用char string[6] = "hollis";的形式）。
equals()和hashcode()之间关系
在判断两个对象是否相等时，不要只使用equals方法判断。还要考虑其哈希码是否相等。尤为是和hashMap等与hash相关的数据结构一块儿使用时。
一、若是两个对象相等，那么他们必定有相同的哈希值（hash code）。
二、若是两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（须要再经过equals来判断）

关键字

四种访问控制区别图
泛型中K T V E ？ object等的含义
E – Element (在集合中使用，由于集合中存放的是元素)
T – Type（Java 类）
K – Key（键）
V – Value（值）
N – Number（数值类型）
？ – 表示不肯定的java类型（无限制通配符类型）
Object – 是全部类的根类，任何类的对象均可以设置给该Object引用变量，使用的时候可能须要类型强制转换，可是用使用了泛型T、E等这些标识符后，在实际用以前类型就已经肯定了，不须要再进行类型强制转换。
可变参数
它容许一个方法把任意数量的值做为参数。
可变参数的工做原理
可变参数在被使用的时候，他首先会建立一个数组，数组的长度就是调用该方法是传递的实参的个数，而后再把参数值所有放到这个数组当中，而后再把这个数组做为参数传递到被调用的方法中。
实例函数
```
public static void main(String[] args) {
    print("a");
    print("a", "b");
    print("a", "b", "c");
}

public static void print(String ... s){
    for(String a: s)
        System.out.println(a);
}
```

Comparable和Comparator

做用
用来作对象之间的比较的和对象排序。
Comparator实例

class Dog {
    int size;

    Dog(int s) {
        size = s;
    }
}

class SizeComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog d1, Dog d2) {
        return d1.size - d2.size;
    }
}

public class ImpComparable {
    public static void main(String[] args) {
        TreeSet<Dog> d = new TreeSet<Dog>(new SizeComparator()); // pass comparator
        d.add(new Dog(1));
        d.add(new Dog(2));
        d.add(new Dog(1));
    }
}

Comparable实例

class Dog implements Comparable<Dog>{
    int size;

    Dog(int s) {
        size = s;
    }

    @Override
    public int compareTo(Dog o) {
        return o.size - this.size;
    }
}

public class ImpComparable {
    public static void main(String[] args) {
        TreeSet<Dog> d = new TreeSet<Dog>();
        d.add(new Dog(1));
        d.add(new Dog(2));
        d.add(new Dog(1));
    }
}

重载（Overloading）

定义
简单说，就是函数或者方法有一样的名称，可是参数列表不相同的情形，这样的同名不一样参数的函数或者方法之间，互相称之为重载函数或者方法。

实例

class Dog{
    public void bark(){
        System.out.println("woof ");
    }

    //overloading method
    public void bark(int num){
        for(int i=0; i<num; i++)
            System.out.println("woof ");
    }
}

重写（Overriding）

定义
重写指的是在Java的子类与父类中有两个名称、参数列表都相同的方法的状况。因为他们具备相同的方法签名，因此子类中的新方法将覆盖父类中原有的方法。

实例

class Dog{
    public void bark(){
        System.out.println("woof ");
    }
}
class Hound extends Dog{
    public void sniff(){
        System.out.println("sniff ");
    }

    public void bark(){
        System.out.println("bowl");
    }
}

public class OverridingTest{
    public static void main(String [] args){
        Dog dog = new Hound();
        dog.bark();
    }
}

//最终输出：bowl

组合和继承

组合定义
其实所谓的组合就是建立一个新类去调用已经建立而且调试好的类，那么这个新类就能够把它叫作是一个组合。例如：A类中有一个属性对象B，那么这个A类就是一个组合类。
继承定义
经过extends的关键字，它能够帮助咱们继承，被继承的类咱们称做父类，也能够叫作基类，超类都行，而继承者咱们称做子类或者派生类等等。
二者比较

建议在一样可行的状况下，优先使用组合而不是继承。由于组合更安全，更简单，更灵活，更高效。继承要慎用，其使用场合仅限于你确信使用该技术有效的状况。一个判断方法是，问一问本身是否须要重新类向基类进行向上转型。若是是必须的，则继承是必要的。反之则应该好好考虑是否须要继承。

迭代与递归

实例

//Q1：n*(n-1)*(n-2) = ？

//递归
int factorial (int n) {
    if (n == 1) {
        return 1;
    } else {
        return n*factorial(n-1);
    }
}

//迭代
int factorial (int n) {
    int product = 1;
    for(int i=2; i<n; i++) {
        product *= i;
    }
    return product;
}

//Q2：fib(n-1) + fib(n-2) = ？

//递归
int fib (int n) {
    if (n == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else {
        return fib(n-1) + fib(n-2);
    }
}

//迭代
int fib (int n) {
    int fib = 0;
    int a = 1;
    for(int i=0; i<n; i++) {
       int temp = fib;
        fib = fib + a;
        a = temp;
    }
    return fib;
}

二者比较图

从对比图建议能不用递归就不用递归，递归多数均可以用迭代来代替。

反射

使用场景
用于动态代理和动态建立类，获取对象全部属性和方法（包含私有默认父类）。java中全部对象都是Class这个类的实例对象；经过Class这个类对象就能够实现反射机制。
优势：反射机制就是增长程序的灵活性，避免将程序写死到代码里。如struts中请求的派发控制，当请求来到时，struts经过查询配置文件，找到该请求对应的action方法，而后经过反射实例化action，并调用响应method。
缺点：对性能有必定影响
得到Class的三种方式
一、经过 Object 类中的 getClass() 方法，知道对象时用
```
Person p1 = new Person();
Class<?> c1 = p1.getClass();
```
二、直接经过类名.class 的方式获得,该方法最为安全可靠，程序性能更高，说明任何一个类都有一个隐含的静态成员变量 class，
```
Class<?> c2 = Person.class;
```
三、经过 Class 对象的 forName() 静态方法来获取，用的最多，但可能抛出 ClassNotFoundException 异常，主要用于动态代理。
```
Class<?> c3 = Class.forName("com.ys.reflex.Person");
```
类加载图

上图可知：一个类在 JVM 中只会有一个 Class 实例,即咱们对上面获取的 c1,c2,c3进行 equals 比较，发现都是true。

经过反射获取构造方法实例

package fanshe;
 
public class Student {
    
    //---------------构造方法-------------------
    //（默认的构造方法）
    Student(String str){
        System.out.println("(默认)的构造方法 s = " + str);
    }
    
    //无参构造方法
    public Student(){
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }
    
    //有一个参数的构造方法
    public Student(char name){
        System.out.println("姓名：" + name);
    }
    
    //有多个参数的构造方法
    public Student(String name ,int age){
        System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，之后解决。
    }
    
    //受保护的构造方法
    protected Student(boolean n){
        System.out.println("受保护的构造方法 n = " + n);
    }
    
    //私有构造方法
    private Student(int age){
        System.out.println("私有的构造方法   年龄："+ age);
    }
 
}

//测试类
package fanshe;
import java.lang.reflect.Constructor;
 
public class Constructors {
 
    public static void main(String[] args) throws Exception {
        //1.加载Class对象
        Class clazz = Class.forName("fanshe.Student");
        
        
        //2.获取全部公有构造方法
        System.out.println("**********************全部公有构造方法*********************************");
        Constructor[] conArray = clazz.getConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }
        
        
        System.out.println("************全部的构造方法(包括：私有、受保护、默认、公有)***************");
        conArray = clazz.getDeclaredConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }
        
        System.out.println("*****************获取公有、无参的构造方法*******************************");
        Constructor con = clazz.getConstructor(null);
        //1>、由于是无参的构造方法因此类型是一个null,不写也能够：这里须要的是一个参数的类型，切记是类型
        //2>、返回的是描述这个无参构造函数的类对象。
    
        System.out.println("con = " + con);
        //调用构造方法
        Object obj = con.newInstance();
    //    System.out.println("obj = " + obj);
    //    Student stu = (Student)obj;
        
        System.out.println("******************获取私有构造方法，并调用*******************************");
        con = clazz.getDeclaredConstructor(char.class);
        System.out.println(con);
        //调用构造方法
        con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
        obj = con.newInstance('男');
    }
    
}

获取成员变量实例

package fanshe.field;
 
public class Student {
    public Student(){
        
    }
    //**********字段*************//
    public String name;
    protected int age;
    char sex;
    private String phoneNum;
    
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", phoneNum=" + phoneNum + "]";
    }
    
}

//测试类
package fanshe.field;
import java.lang.reflect.Field;

public class Fields {
 
        public static void main(String[] args) throws Exception {
            //1.获取Class对象
            Class stuClass = Class.forName("fanshe.field.Student");
            //2.获取字段
            System.out.println("************获取全部公有的字段********************");
            Field[] fieldArray = stuClass.getFields();
            for(Field f : fieldArray){
                System.out.println(f);
            }
            System.out.println("************获取全部的字段(包括私有、受保护、默认的)********************");
            fieldArray = stuClass.getDeclaredFields();
            for(Field f : fieldArray){
                System.out.println(f);
            }
            System.out.println("*************获取公有字段**并调用***********************************");
            Field f = stuClass.getField("name");
            System.out.println(f);
            //获取一个对象
            Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
            //为字段设置值
            f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
            //验证
            Student stu = (Student)obj;
            System.out.println("验证姓名：" + stu.name);
            
            
            System.out.println("**************获取私有字段****并调用********************************");
            f = stuClass.getDeclaredField("phoneNum");
            System.out.println(f);
            f.setAccessible(true);//暴力反射，解除私有限定
            f.set(obj, "18888889999");
            System.out.println("验证电话：" + stu);
            
        }
    }

获取成员方法实例

package fanshe.method;
 
public class Student {
    //**************成员方法***************//
    public void show1(String s){
        System.out.println("调用了：公有的，String参数的show1(): s = " + s);
    }
    protected void show2(){
        System.out.println("调用了：受保护的，无参的show2()");
    }
    void show3(){
        System.out.println("调用了：默认的，无参的show3()");
    }
    private String show4(int age){
        System.out.println("调用了，私有的，而且有返回值的，int参数的show4(): age = " + age);
        return "abcd";
    }
}

//测试类
package fanshe.method;
import java.lang.reflect.Method;

public class MethodClass {
 
    public static void main(String[] args) throws Exception {
        //1.获取Class对象
        Class stuClass = Class.forName("fanshe.method.Student");
        //2.获取全部公有方法
        System.out.println("***************获取全部的”公有“方法*******************");
        stuClass.getMethods();
        Method[] methodArray = stuClass.getMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        System.out.println("***************获取全部的方法，包括私有的*******************");
        methodArray = stuClass.getDeclaredMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        System.out.println("***************获取公有的show1()方法*******************");
        Method m = stuClass.getMethod("show1", String.class);
        System.out.println(m);
        //实例化一个Student对象
        Object obj = stuClass.getConstructor().newInstance();
        m.invoke(obj, "刘德华");
        
        System.out.println("***************获取私有的show4()方法******************");
        m = stuClass.getDeclaredMethod("show4", int.class);
        System.out.println(m);
        m.setAccessible(true);//解除私有限定
        Object result = m.invoke(obj, 20);//须要两个参数，一个是要调用的对象（获取有反射），一个是实参
        System.out.println("返回值：" + result);
        
        
    }
}

经过反射运行配置文件内容实例

public class Student {
    public void show(){
        System.out.println("is show()");
    }
}

配置文件以txt文件为例子（pro.txt）：

className = cn.fanshe.Student
methodName = show

测试类：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;
 
public class Demo {
    public static void main(String[] args) throws Exception {
        //经过反射获取Class对象
        Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
        //2获取show()方法
        Method m = stuClass.getMethod(getValue("methodName"));//show
        //3.调用show()方法
        m.invoke(stuClass.getConstructor().newInstance());
        
    }
    
    //此方法接收一个key，在配置文件中获取相应的value
    public static String getValue(String key) throws IOException{
        Properties pro = new Properties();//获取配置文件的对象
        FileReader in = new FileReader("pro.txt");//获取输入流
        pro.load(in);//将流加载到配置文件对象中
        in.close();
        return pro.getProperty(key);//返回根据key获取的value值
    }
}

当咱们升级这个系统时，不要Student类，而须要新写一个Student2的类时，这时只须要更改pro.txt的文件内容就能够了。代码就一点不用改动

public class Student2 {
    public void show2(){
        System.out.println("is show2()");
    }
}

配置文件更改成：

className = cn.fanshe.Student2
methodName = show2

序列化和反序列化

序列化：对象序列化的最主要的用处就是在传递和保存对象的时候，保证对象的完整性和可传递性。序列化是把对象转换成有序字节流，以便在网络上传输或者保存在本地文件中。序列化后的字节流保存了Java对象的状态以及相关的描述信息。序列化机制的核心做用就是对象状态的保存与重建。
反序列化：客户端从文件中或网络上得到序列化后的对象字节流后，根据字节流中所保存的对象状态及描述信息，经过反序列化重建对象。
本质上讲，序列化就是把实体对象状态按照必定的格式写入到有序字节流，反序列化就是从有序字节流重建对象，恢复对象状态
使用场景
一、永久性保存对象，保存对象的字节序列到本地文件或者数据库中；
二、经过序列化以字节流的形式使对象在网络中进行传递和接收；
三、经过序列化在进程间传递对象；
缺点
一、序列化后的码流太大
二、序列化性能太差
实现要求
只有实现了Serializable或Externalizable接口的类的对象才能被序列化，不然抛出异常！