Java知识大整理(1) Java基础知识

Java知识整理

  • 概念问题
      • 面向对象和面向过程
      • Java和C++
      • Java 语言特点
      • JDK 和 JRE和JVM
      • Oracle JDK 和 OpenJDK
      • 字符型常量和字符串常量
      • 构造器 Constructor 是否可被 override
      • override重写和overload重载
      • 面向对象三大特性: 封装 继承 多态
      • String 、 StringBuffer 和 StringBuilder
      • 自动装箱与拆箱
      • 定义一个不做事且没有参数的构造方法的作用
      • java和javax:javax包成为标准一部分
      • 接口和抽象类
      • 基本与包装类型使用标准
      • 自动装箱
      • equlas注意事项
      • 成员变量与局部变量
      • == 与 equals
      • hashCode 与 equals
      • 线程、程序、进程
      • 线程基本状态
      • final关键字
      • 异常处理
      • Throwable类常用方法
      • 字段不希望序列化
      • 获取用键盘输入
      • 内部类
      • staic
      • I/O流
      • BIO、NIO、AIO
      • 浅拷贝和深拷贝
      • Collection
          • 排序操作
          • 查找、替换
      • Arrays操作
      • BigDecimal的用处
      • Arrays.asList使用
      • 正确将数组转化为ArrayList
          • 简单方法
          • java8的steam
          • 不要在 foreach 循环里进行元素的 remove/add 操作
      • Collection.toArray转为数组
      • 泛型限定
      • 泛型数组(重点)
      • 可重入/不可重入锁
      • 乐观锁、悲观锁

概念问题

面向对象和面向过程

Java和C++

Java 语言特点

JDK 和 JRE和JVM

Oracle JDK 和 OpenJDK

字符型常量和字符串常量

构造器 Constructor 是否可被 override

override重写和overload重载

面向对象三大特性: 封装 继承 多态

String 、 StringBuffer 和 StringBuilder

自动装箱与拆箱

定义一个不做事且没有参数的构造方法的作用

java和javax:javax包成为标准一部分

接口和抽象类

  • 方法:接口默认public,不可实现;抽象类可有非抽象方法
  • 变量:接口只能有static和final
  • 一个类可多接口,单抽象类
  • 理念:抽象类是模板;接口是行为抽象。
public interface DoSomething {
   static String name="null";
   final String type="animal type";
   String getAnimalName();
}

public interface EatSomething {
   String eat();
}

public abstract class Animal {
    abstract public String getName();
    public String getType(){
        return "not a human";
    }
}

public class Dog extends Animal implements DoSomething,EatSomething {
    @Override
    public String getName() {
        return null;
    }

    @Override
    public String getAnimalName() {
        return null;
    }

    @Override
    public String eat() {
        return null;
    }
}


JDK8中,接口可定义静态方法。

public interface EatSomething {
    String eat();

    static String getPlaceName() {
        return "house";
    }
}

基本与包装类型使用标准

  • POJO类必须使用包装数据类型。
  • RPC方法返回值和参数必须使用包装类型。
  • 局部变量使用基本数据类型。

NPE问题:Null Pointer Exception空指针例外。Integer的null和0表示不同意思,而int没有null,就无法区分意思。

自动装箱

自动装箱创建Integer对象,数值在-128~127,将创建的Integer缓存起来,下次再出现该数值,直接从缓存去对象。
(IDEA阿里巴巴的p3c插件会检测==错误)。

        int x=3;
        int y=3;
        System.out.println("x==y:"+(x==y));
        
        Integer x1=new Integer(3);
        Integer y1=new Integer(3);
        System.out.println("x1==y1:"+(x1==y1));
        System.out.println("x1.equals(y1):"+(x1.equals(y1)));

上面x和y引用的是相同的对象。

equlas注意事项

jdk7引入Objects.equals(…,…)更好地避免equals调用出错。

成员变量与局部变量

== 与 equals

public class Test {
    public static void main(String[] args) {
        String s = new String("nihao");
        String s1 = new String("nihao");
        System.out.println("s==s1:"+(s==s1));
        System.out.println("s.equals(s1):"+(s.equals(s1)));
    }
}

结果:

特殊情况:常量池的作用

    String aa = "ab"; // 放在常量池中
    String bb = "ab"; // 从常量池中查找
        String aa="ab";
        String bb="ab";
        System.out.println("aa==bb:"+(aa==bb));
        System.out.println("aa.equals(bb):"+(aa.equals(bb)));

结果:
在这里插入图片描述

hashCode 与 equals

 String s = new String("nihao");
        String s1=new String("nihao");
        System.out.println("s:"+s);
        System.out.println("s1:"+s1);
        System.out.println("s.equals(s1):"+(s.equals(s1)));
        System.out.println("s.hashcode:"+s.hashCode());
        System.out.println("s1.hashcode:"+s1.hashCode());

  

结果:
Java知识大整理(1) Java基础知识_第1张图片
重点注意: equals 方法被覆盖过,则 hashCode 方法也必须被覆盖。
如果hashcode相同,则比较equals。

线程、程序、进程

线程基本状态

final关键字

  • 变量
  • 方法(方法锁定,以防任何继承类修改它的含义;第二个原因是效率)。
  • 类(类不能被继承)

异常处理

Java知识大整理(1) Java基础知识_第2张图片

  • Error(错误):是程序无法处理的错误。
  • Exception(异常):是程序本身可以处理的异。
  • 注意:异常和错误的区别:异常能被程序本身处理,错误是无法处理。

Throwable类常用方法

public class MyThrowable extends Throwable {
    //返回异常发生时的简要描述
    @Override
    public String getMessage() {
        return "wait,这里可能出现了问题";
    }
    //返回异常发生时的详细信息
    @Override
    public String toString() {
        return "我的异常类";
    }
    //返回异常对象的本地化信息。
    // 使用Throwable的子类覆盖这个方法,可以生成本地化信息。
    // 如果子类没有覆盖该方法,则该方法返回的信息与getMessage()
    // 返回的结果相同
    @Override
    public String getLocalizedMessage() {
        return this.getMessage();
    }
    //在控制台上打印Throwable对象封装的异常信息
    @Override
    public void printStackTrace() {
        super.printStackTrace();
    }
}
public static void main(String[] args) {
        try{
            throw new MyThrowable();
        }catch (MyThrowable myThrowable){
            myThrowable.printStackTrace();
            System.out.println("-----------------------");
            System.out.println(myThrowable.getMessage());
            System.out.println(myThrowable.toString());
        }
    }

结果:
Java知识大整理(1) Java基础知识_第3张图片

  • try:其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。
  • catch:用于处理try捕获到的异常
  • finally:无论是否捕获或处理异常,finally块里的语句都会被执行。当在try块或catch块中遇到return 语句时,finally语句块将在方法返回之前被执行。
catch (MyThrowable myThrowable){
            ....
            return;
        }
        finally {
            System.out.println("你必须执行我finally不可");
        }

结果为:
Java知识大整理(1) Java基础知识_第4张图片

字段不希望序列化

transient关键字,阻止实例中那些用此关键字修饰的的变量序列化;

获取用键盘输入

两种方式

        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        System.out.println(s);

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String s1 = reader.readLine();
        System.out.println(s1);

内部类

  • 成员内部类
        //静态内部类
        Circle.Draw draw = new Circle.Draw();
        //非静态内部类
        Circle circle = new Circle(1);
        Circle.Made made = circle.new Made();

  • 局部内部类
  • 静态内部类
  • 匿名内部类
scan_bt.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
 }});
         
history_bt.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {}});

与以上匿名内部类相同的作用代码为:

private void setListener()
{
    scan_bt.setOnClickListener(new Listener1());       
    history_bt.setOnClickListener(new Listener2());
}
 
class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
}
 
class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
}

staic

  • 变量、方法
  • 静态代码块:静态代码块—>非静态代码块—>构造方法。
  • 静态内部类
  • 静态导包(1.5新特性)
静态代码块和非静态代码块
public class Dog {
    {
        System.out.println("这里是非静态代码块");
    }
    static {
        System.out.println("这里是静态代码块");
    }
    public Dog(){
        System.out.println("这里是构造函数");
    }
}

结果为:
Java知识大整理(1) Java基础知识_第5张图片

I/O流

基类:
InputStream/Reader: 所有的输入流的基类
OutputStream/Writer: 所有输出流的基类

BIO、NIO、AIO

  • BIO: 阻塞IO
  • NIO: 同步非阻塞IO
  • AIO: 异步非阻塞的IO

浅拷贝和深拷贝

Collection

  • 排序
  • 查找、替换
  • 同步控制(可以用JUC包并发集合替代)
排序操作
public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(4);
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println("开始序列:"+list);

        Collections.reverse(list);
        System.out.println("翻转后:"+list);

        Collections.shuffle(list);
        System.out.println("随机后:"+list);

        Collections.sort(list);
        System.out.println("排序后:"+list);

        Collections.swap(list,0,3);
        System.out.println("交换第1和3个后:"+list);

        //定制sort
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -o1.compareTo(o2);
            }
        });
        System.out.println("定制sort后:"+list);


    }
查找、替换
        System.out.println(list+" 二分查找3:"+Collections.binarySearch(list,3));

        System.out.println("最大元素:"+Collections.max(list));

        System.out.println("3出现次数:"+Collections.frequency(list,3));

        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(3);
        list1.add(2);
        System.out.println("3,2出现在哪里:"+Collections.indexOfSubList(list,list1));

结果为:
Java知识大整理(1) Java基础知识_第6张图片

Arrays操作

        int arr[]={5,4,3,2,1};
        Arrays.sort(arr,1,3);
        System.out.println("arr排序1到3:"+Arrays.toString(arr));

        Arrays.sort(arr);
        System.out.println("arr排序后:"+Arrays.toString(arr));

        System.out.println(Arrays.toString(arr));
        System.out.println("4在位置:"+Arrays.binarySearch(arr,4));


结果为:
Java知识大整理(1) Java基础知识_第7张图片
剩下还有:

  • 比较 equals
  • 填充 fill
  • 转列表 asList
  • 转字符串 toString
  • 复制 copyOf

BigDecimal的用处

浮点数之间等值判断不能使用==来比较,包装数据类型不能用equals来比较。

BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("0.9");
        BigDecimal c = new BigDecimal("0.8");
        BigDecimal x = a.subtract(b);
        BigDecimal y = b.subtract(c);
        System.out.println("两结果之间进行对比:"+x.equals(y));
        //保留几位小数n
        BigDecimal m = new BigDecimal("1.2223456");
        BigDecimal n = m.setScale(3, BigDecimal.ROUND_HALF_DOWN);
        System.out.println(m+"保留三位:"+n);

结果显示为:
在这里插入图片描述

Arrays.asList使用

注意必须传入对象数组,基本类型不可以。
且底层就是数组。
最重要的是,Arrays.asList() 方法返回的并不是 java.util.ArrayList ,而是 java.util.Arrays 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。

        Integer arrls[]={8,7,6,5};
        List<Integer> list = Arrays.asList(arrls);
        System.out.println("使用asList后:"+list.toString());

正确将数组转化为ArrayList

简单方法

new ArrayList<>(Arrays.asList(“a”, “b”, “c”))

java8的steam
不要在 foreach 循环里进行元素的 remove/add 操作

可以用迭代器的remove方法,否则抛出异常。
fail-fast机制: :多线程操作集合,一线程访问集合,但检测到集合被其他线程修改,便会出现情况。java.util包下面的所有的集合类都是fail-fast的,而java.util.concurrent包下面的所有的类都是fail-safe的。

Collection.toArray转为数组

list.toArray(new String[0])
这里只为指定返回的数组的类型。0是为节省空间。

泛型限定

    public static  <T extends Comparable<? super T>> T  Min(T[] nums){
        T val=nums[0];
        for(int i=1;i<nums.length;i++){
            if(val.compareTo(nums[i])>0){
                val=nums[i];
            }
        }
        return val;
    }

其中T extends Number表明上限是Number,也就是T必须是Number的子类。? super T 表明下限是T。

例如Integer是这样定义的:

public final class Integer extends Number implements Comparable<Integer>
  • T表示泛型
  • ? 表示不确定的类型,一般用在通配
  • Object表示java中所有类的父类,在集合中使用时要格外注意。
  • jdk为了便于理解,用K表示键,V表示值,T表示type类型,E表示enum枚举,其实这四个都只是符号,都是表示泛型名称。换成其他字母都没关系,但是都要在之前声明。

泛型数组(重点)

可重入/不可重入锁

  • 不可重入:线程获取锁,再次获取锁时,就会被阻塞。
  • 可重入: 线程可以进入已经拥有锁的同步代码块。
isLocked false
lockedBy null
lockedCount 0

进入lock():
thread为当前线程。
由于while(isLocked && lockedBy != thread),而isLocked为false,所以不执行while内的wait,而是

isLocked true
lockedBy 当前线程
lockedCount 1

接着这个线程再次申请这个锁,由于满足lockedBy与当前线程匹配,所以仍不能执行while,而是

isLocked true
lockedBy 当前线程
lockedCount 2

如果此时有其它线程执行lock(),那么就会满足while的条件,而执行wait(),挂起等待。

总结:如此便实现了一个线程可以重入一个锁。

乐观锁、悲观锁

  • synchronized是悲观锁,这种线程一旦得到锁,其他需要锁的线程就挂起。
  • CAS是乐观锁,每次不加锁,有冲突就重试。

CAS( Compare And Swap )比较并替换。

你可能感兴趣的:(学习,代码,java,抽象类,jdk,多态,接口)