java知识查漏补缺

一、重写(override)和重载(overload)的区别

二者除了名字相似,其实没什么联系

范围不同:重载发生在同一个类的不同方法之间。重写发生在父类和子类自荐。

前提:

重载要求:方法名相同,参数列表不同,对于返回值类型不要求相同。

重写要求:方法名形同,参数列表也相同。重写是实现多态的关键,注意如果父类中的方法是private类型,那么子类中对应方法不算重载,而相当于是定义了一个新方法。

二、final的用法

修饰类:该类不能被继承

修饰方法:该方法不能被重写

修饰属性:该属性初始化后不能被修改

1,方法可以多态,Fields不能实现多态。

2,利用父类的引用调用子类的方法呈现子类的特征成为多态。

3,不能利用父类的引用去调用子类没有实现的方法,除非进行强制转换。

 

三、java实现的几种设计模式

3.1单例模式

作用:对于某些系统资源,比如可能只有一个窗口管理器等等,取消自由创建对象的系统开销。

单例类创建的注意点:

1)有一个该类的实例作为类属性。

2)构造函数为private类型

3)通过一个类方法获取类的唯一实例

package com.bobo.interview;

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

    public Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

     

}
单例模式

 这种有一个隐藏的问题,多线程,试想,如果两个线程同时去判断instance是否为空,那么就可能生成两个不同的对象,对此解决方法是

1)加同步锁(注意加的位置)

package com.bobo.interview;

import java.util.concurrent.locks.Lock;

public class SingleTon2 {
    private SingleTon2 instance;

    private SingleTon2() {

    }

    public SingleTon2 getInstance() {
        if (instance == null) {
            synchronized (this) {
                if (instance == null) {
                    instance = new SingleTon2();
                }
            }
        }
        return instance;

    }

}
单例类实现方式1

注意,判断两次是否为空,只有再第一次生成对象的时候,才需要加同步锁。而不是每次判断为空的时候都加,从而提高代码效率

2)使用类成员变量

package com.bobo.interview;

public class SingleTon3 {
    private static SingleTon3 instance=new SingleTon3();
    private SingleTon3(){
        
    }
    public SingleTon3 getInstance(){
        return instance;
    }

}
基于类成员变量实现单例模式

3.2不可变类

作用:利用java.lang.String等,并且绝对线程安全

创建的注意点:

1)使用private和final修饰类的field

2)提供代参数的构造器,用户根据传入参数来初始化类的field

3)仅仅提供getter,不能提供setter

4)如果有必要,重写类的equals和hashcode方法(根据关键的field来判断)

有些情况,还可以为不可变类增添缓存。

 

3.3简单工厂模式

作用:“面向接口”编程,降低耦合。

第一步:定义接口
package com.bobo.desing;

public interface Output {
    int MAX_CHCHE_LINE=50;
    void out();
 
}

第二部:定义接口的实现类
package com.bobo.desing;

public class Print1 implements Output{

    @Override
    public void out() {
        System.out.println("print2的out方法");
        
    }

     

}


package com.bobo.desing;

public class Print2 implements Output{

    @Override
    public void out() {
        System.out.println("print1的out方法");
        
    }

     

}


第三部:定义工厂类
package com.bobo.desing;

public class PrintFactory {
    public Output getOutput(){
        return new Print1();
    }
}


第四部:构建最终的实体类
package com.bobo.desing;

public class Computer {
    private Output op;

    public Computer(Output output) {
         this.op=output;
    }
    public void work(){
        op.out();
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        PrintFactory  factory=new PrintFactory();
        //这样如果需要为计算器更换打印机时,只需要factory返回不同的print对象即可,从而避免了硬耦合
        Computer co=new Computer(factory.getOutput());
        co.work();
    }

}
简单工厂设计模式

 

 3.4命令模式

对于下列场景:某个方法需要完成某一个行为,但是这个行为的具体实现无法确定,必须等到执行该方法的时候才可以确定。也就是说,方法不仅仅需要根据传入的数据变换,而且方法的执行体也需要变化。

第一步:实现接口
package com.bobo.desing;

public interface Command {
    void process(int[] target);

}


第二部:实现了接口的相关类
package com.bobo.desing;

public class AddCommand implements Command {

    @Override
    public void process(int[] target) {
        int sum = 0;
        for (int var : target) {
            sum += var;
        }
        System.out.println(sum + "");
    }

}


package com.bobo.desing;

public class PrintCommand implements Command{

    @Override
    public void process(int[] target) {
        // TODO Auto-generated method stub
        for(int var:target){
            System.out.print(var+" ");
        }
        System.out.println();
    }

}


第三部:
package com.bobo.desing;

public class ProcessArray {

    public void process(int[] target, Command cmd) {
        // TODO Auto-generated method stub
        cmd.process(target);
    }

}


第四部:
package com.bobo.desing;

public class CommandTest {
    
    
    public static void main(String args){
        ProcessArray pa=new ProcessArray();
        int array[]={1,2,3,4};
        Command cmd=new AddCommand();
        Command cmd2=new PrintCommand();
        pa.process(array,cmd2);
    }

}
命令模式

 

四、java接口

java的接口可以同时继承多个接口,不能继承类;java中的类只能实现单继承

接口中的方法,默认是public类型,接口中的field,默认是public static final类型

接口和抽象类的区别:

区别主要体现在设计目的上,接口体现的是一种规范,作为系统和外部交互的窗口。抽象类体现的则是一种模板式的设计理念。

在目的上:

1)接口中只能包含抽象方法;抽象类可以包含普通方法,抽象类可以不包含抽象方法,但包含抽象方法的一定是抽象类。

2)接口中不能定义静态方法,抽象类可以

3)接口只能定义public static final类型的field。

4)接口可以继承多个接口,抽象类只能单继承

5)接口不能包含构造器;抽象类可以,抽象类的构造器并不是为了创建对象,而是供子类的构造器调用。

 类和组合的方式:

一个是is a的关系,一个是has a的关系

五、常见的jar命令

jar与zip文件的区别在于多了清单文件:META_INF/MANIFEST.MF

1,创建jar文件 jar cvf test.jar test

2, 解压缩:jar xvf test.jar

3,添加main,生成一个可执行的jar文件:jar cvfe test.jar test *.class

4,执行带有main的jar: java -jar test.jar或者javaw test.jar

 

六、几个类的区别

StringBuffer与StringBuilder:StringBuffer线程安全,StringBuilder反之

ArrayList与vector:Vector线程安全,ArrayList反之

Hashtable与hashMap:前者线程安全,后者反之;hashtable不允许使用null作为key或者value,Hashmap则可以

集合实现线程安全可以使用Collections工具类的synchronizedXxx()的方法,此外,这个工具类还有shuffle,rotate等方法

 

七、java中的集合和泛型

java中的集合分为set、list和map三大体系

SET:hashSet、LinkedSet(按照插入顺序维护顺序)、TreeSet(基于红黑树,维度大小顺序)

 LIST:ArrayList:基于数组,LinkList:基于链表;Deque:双边队列,可以实现栈或者队列

泛型:本质是一种类型参数

1,集合中使用泛型:菱形

2,泛型类或者泛型接口:public interface List<K,V>{}等

本质上没有泛型类,它们在运行时都是同一种类型,并且List<Person>也不是List<Object>的子类

3,利用extends设定泛型的上限,定义传给其的参数需要是该上限的子类或者上限本身;利用super设定泛型的下限

4,泛型方法:pulbic static<T> functionName(T a){}

 

八、java异常

java中的异常有两种:

checked异常:系统要求必须处理的,如io异常。runtime异常:可以处理也可以不处理的,如空指针异常。

throw抛出一个异常的实例,用在方法体中;throws抛出异常类,用在方法签名中

 

 

 

原文地址:https://www.cnblogs.com/bobodeboke/p/3901509.html