Java基础知识总结-关键字、抽象类、接口、异常、集合、工具类、泛型

Java基础知识总结

• instanceof 操作符
  

• Object类
  

• 对象类型转换
  

• ==与equal方法
  
  
• 包装类
  
  自动装箱，自动拆箱。
  

• 单例设计模式
  使用单例模式解决什么问题？一般都是new对象太费劲，或者没必要频繁new对象。
  

饿汉式单例模式

public class Single {
    private static Single ss = new Single();
    // 私有的构造方法，调用这个类的人就不能直接使用new来创建对象
    private Single(){

    }
    public static Single getInstance()
    {
        return ss;
    }
}
// 测试
Single s = Single.getInstance();

懒汉式单例模式

public class Single {
    // 2.私有化一个对象 注意volatile
    private static volatile Single ss = null;
    // 1. 私有的构造方法，调用这个类的人就不能直接使用new来创建对象
    private Single(){

    }
    // 3.获取方法
    public static Single getInstance()
    {
        if(ss == null)
        {
            // 加锁
            synchronized (Single.class)
            {
                if(ss == null)
                {
                    ss = new Single();
                }
            }

        }
        return ss;

    }
}

• 代码块
  静态代码块内部只能使用静态变量或静态方法；非静态代码块则啥都可以。
  

• 匿名内部类&代码块

   public static void main(String[] args)
    {

        // 构建了一个没有类名的HelloA的子类，也就是匿名的Person的子类，这种类没有类名，就不能用显示的new方式创建对象。
        //这样的情况就要用代码块执行初始化
        HelloA ha = new HelloA(){
            {
                this.a = 99;
            }
            @Override
            public void show() {
                super.show();
            }
        };
        ha.show();
    }

• final关键字
  final修饰的变量是常量，必须要显示赋值；修饰的属性和类表示最终的属性或者类。如果final修饰方法，那么子类中，该方法不能够重写。
  

• 抽象类
  

public abstract class Employee {
    int id;
    String name;
    double salary;
    public abstract void work();

}

• 模板方法设计模式
  
  应用举例
  

public abstract class Template {
    public abstract void code();
    public final void getTime()
    {
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println(" code 方法执行时间： "+(end-start));

    }
}

class TestTemplate extends Template
{

    @Override
    public void code() {
        int k=0;
        for(int i=0;i<50000;i++)
        {
        k++;
        }
        System.out.println("k is: "+k);

    }
}

• 接口
  
  接口的特点：
  

如果类没有实现接口的所有方法，就要定义为抽象类

• 工厂模式
  

• 内部类
  内部类主要解决java不能多重继承的问题，实现变相的多继承。

public class JavaTest {
    public static void main(String[] args)
    {
        new B().test();
    }
}

class A{
    void show()
    {
        System.out.println("A show");
    }
}
class C{
    void show1()
    {
        System.out.println("C show");
    }
}

class B
{
    void test()
    {
        new innerA().show();
        new innerC().show1();
    }
    class innerA extends A
    {
        @Override
        void show() {
            System.out.println("overwrite A show inner BA");
        }
    }
    class innerC extends C{
        @Override
        void show1() {
            System.out.println("overwrite C show inner BC");
        }
    }
}

• 面向对象总结
  

• Java异常
  
  

• 声明抛出异常
  

try-catch捕获异常

        try{
            int i=4;
            int b = i/0;
        }catch (Exception e) // 当不知道捕获的是什么异常时，可以直接使用所有异常的父类Exception
        {
            e.printStackTrace();
            System.out.println("what's wrong: " +e.getMessage());
        }

throw Exception抛出异常，如果一直抛的话，最终是抛出到jvm。

class C
{
    int i;
    public static void test()throws Exception{
        B b= null;
        System.out.println(b.a);
    }
}
// test
    try{
            C.test();
        }catch (Exception e) // 当不知道捕获的是什么异常时，可以直接使用所有异常的父类Exception
        {
            e.printStackTrace();
            System.out.println("what's wrong: " +e.getMessage());
        }

人工抛出异常：

try{
            throw new Exception("try");
        }catch (Exception e) // 当不知道捕获的是什么异常时，可以直接使用所有异常的父类Exception
        {
            e.printStackTrace();
            System.out.println("what's wrong: " +e.getMessage());
        }

        System.out.println("ok ");

// run result
what's wrong: try
java.lang.Exception: try
	at com.study.javastu2.main(javastu2.java:9)
ok 

• set集合（HashSet使用）

Set hs = new HashSet<>();  // 类似Object类型的泛型
        hs.add(9); //集合添加元素
        hs.add("aa");
        hs.add(6);
        hs.add("b");
        hs.add('c');
        hs.add(null);
        hs.remove(6);//一处元素
        System.out.println(hs); // [aa, 9]
        System.out.println(hs.contains(6)); // false  contains是否包含
        // 集合遍历
        // 迭代器遍历集合
        Iterator it = hs.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        // for each 迭代集合
        for(Object obj: hs)  // 把集合的每一个值取出来给obj，直到循环所有的值。  推荐使用
        {
            System.out.println(obj);
        }
        // 如果要让集合只能存同样的类型，该怎么办？
        // 使用范型
        Set<String> s1 = new HashSet<String>();
        s1.add("aa");
        //s1.add(1); 没法存这个，只能String


        hs.clear(); // 清空
        System.out.println(hs); // []

• Treeset集合
  

        Set<Integer> st = new TreeSet<Integer>();
        st.add(5);//添加
        st.add(2);
        st.add(3);
        System.out.println(st); // treeset自然排序   2，3，5
        st.remove(2);//移除
        System.out.println(st.contains(3)); //是否包含

        //遍历 与hashset一致
        Iterator it = st.iterator();
        while(it.hasNext())
        {
            System.out.print(it.next()+"  ");
        }
        System.out.println();
        for(Integer i: st)
        {
            System.out.print(i+" ");
        }

        st.clear(); //清除

• ArrayList集合

     List<String> list =  new ArrayList<String>();
        list.add("bb");
        list.add("cc");
        list.add("aa");
        list.add("aa");
        System.out.println(list.toString());
        list.add(1,"nn");//在指定下标添加元素，其他元素往后移
        System.out.println(list.toString());
        List<String> l = new ArrayList<>();
        l.add("1");l.add("2");
        list.addAll(3,l);//在指定位置插入集合
        System.out.println(list.toString());
        System.out.println(list.indexOf("nn"));//获取元素第一次在元素出现的下标
        System.out.println(list.lastIndexOf("aa"));//获取元素在数组中最后一次出现的下标

        list.remove(5); //移除
        list.set(5,"edit");
        System.out.println(list);

        List sublist = list.subList(2,4);
        System.out.println(sublist);
        System.out.println(list.size());

• map集合
  

Map<String,Integer> mp = new HashMap<>();
        mp.put("a",10);
        mp.put("b",5);
        mp.put("c",7);
        System.out.println(mp);
        System.out.println(mp.size());
        System.out.println(mp.get("a"));
        System.out.println(mp.containsKey("c")); // 判断当前map集合是否包含指定的key
        System.out.println(mp.containsValue("c"));//判断当前map集合是否包含指定的value
        //mp.clear();// 清空

        //遍历map集合
        Set<String> keys = mp.keySet(); // 获取key的集合
        mp.values(); // 获取map的value 集合
        //通过map.keySet()遍历map集合
        for(String key:keys)
        {
            System.out.println("key is:" + key+ " values: "+ mp.get(key));
        }

        // 通过map.entrySet集合遍历
        Set<Map.Entry<String,Integer>> setentyry = mp.entrySet();
        for(Map.Entry<String,Integer> entry: setentyry)
        {
            System.out.println(entry.getKey()+" ====  "+entry.getValue());

        }

• TreeMap
  

• Collection集合
  
  

 List<String> list = new ArrayList<>();
        list.add("b");
        list.add("cd");
        list.add("a");
        list.add("l");
        System.out.println(list);
        Collections.reverse(list);   // 饭庄
        System.out.println(list);
        Collections.shuffle(list); // 随机
        System.out.println(list);
        Collections.sort(list); // 排序
        Collections.swap(list,0,3); // 交换

• 泛型的使用

泛型类

        AF<String> af = new AF<>();
         af.setKey("hello");
        String a1 = af.getKey();

        AF<Integer> af2 = new AF<>();
        af2.setKey(65);
        Integer a2 =af2.getKey();

        AF af3 = new AF();  //相当指定Object泛型
        af3.setKey(new Object());
        Object obj = af3.getKey();
/*
此处的泛型T的取名可以任意取
一般使用T，意味type
 */
class AF<T>
{
    private T key;
    public void setKey(T key)
    {
        this.key = key;
    }
    public T getKey()
    {
        return this.key;
    }
}

泛型接口

public class Test5 {

    public static void main(String[] args)
    {
        B1<Object> b1 = new B1<>();
        B1<String> b2 = new B1<>(); // 未指定泛型类型

        B2 b3 = new B2(); // 不需要指定泛型，指定泛型反而是错误的。
    }
}
interface IB<T>
{
    T test(T t);
}

class B1<T> implements IB<T>{

    @Override
    public T test(T t) {
        return null;
    }
}
class B2 implements IB<Integer>{

    @Override
    public Integer test(Integer integer) {
        System.out.println("implements: "+ integer);
        return integer;
    }
}

泛型方法

public class Test5 {

    public static void main(String[] args)
    {
        CC<Object> c = new CC<Object>();

        //泛型方法，在调用之前没有固定的数据类型
        //在调用时，传入是什么类型，就改为什么类型。
        c.test("xxx");
        c.test1(2);
    }
}


class CC<E>
{
    private E e;
    //无返回值的泛型方法
    public <T> void test(T t)
    {
        // 在类上定义泛型，可以在普通方法中调用
        System.out.println(this.e);
        T s = t;
    }
    //有返回值的泛型方法
    public <T> T test1(T s)
    {
        T t1 = s;
        return t1;
    }
    public void test2(String... args)
    {
        for(String t: args)
            System.out.println(t);
    }

    public <T> void test2(T... args)
    {
        for(T t: args)
            System.out.println(t);
    }
}