java练习 2021-9-21

哪个关键字可以对对象加互斥锁

1、synchronized：保证原子性，有序性，可见性；
被volatile关键字修饰的实例变量或者类变量具备两层语义：
保证了不同线程之间对共享变量的可见性，
禁止对volatile变量进行重排序。
2、volatile：有序性，可见性；volatile用与修饰实例变量和类变量,是一种维护线程安全的手段,作用是实现共享资源的可见性。

有一个源代码，只包含import java.util.*

这一个import语句，能访问java/util目录下的所有类，不能访问java/util子目录下的所有类

volatile与synchronized

volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性。

volatile和synchronized区别
***使用上区别：
volatile关键字只能用来修饰实例变量或者类变量，不能修饰方法已及方法参数和局部变量和常量。
synchronized关键字不能用来修饰变量，只能用于修饰方法和语句块。
volatile修饰的变量可以为空，同步块的monitor不能为空。
***对原子性的保证
volatile无法保证原子性
synchronizde能够保证。因为无法被中途打断。
***对可见性的保证
都可以实现共享资源的可见性，但是实现的机制不同，synchronized借助于JVM指令monitor enter 和monitor exit ，通过排他的机制使线程串行通过同步块，在monitor退出后所共享的内存会被刷新到主内存中。volatile使用机器指令(硬编码)的方式，“lock”迫使其他线程工作内存中的数据失效，不得不主内存继续加载。
***对有序性的保证
volatile关键字禁止JVM编译器已及处理器对其进行重排序，能够保证有序性。
synchronized保证顺序性是串行化的结果，但同步块里的语句是会发生指令从排。
***其他：
volatile不会使线程陷入阻塞
synchronized会使线程进入阻塞。

抽象类和接口

（一）java抽象类和接口在语法上的区别有以下几点：
1、抽象类在java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是一个类却可以实现多个接口。继承抽象类使用的关键字为extends，实现接口使用的是implements关键字，继承写在前面，实现接口写在后面。
2、再抽象类中可以有自己的数据成员，也可以由非abstract的成员方法，而在接口中只能有静态的不能被修改的数据成员，接口中所有的方法都是abstract的。
3、实现接口的类必须实现其中的所有方法，接口中不能有实现方法。继承自抽象类的子类实现所有的抽象方法，抽象类中可以有非抽象方法。
4、接口中默认的变量默认是public static final型，且必须赋予初值，所有实现类中不能重新定义，也不能改变其值。抽象类中的变量默认为friendly权限，其值可以在子类中重新定义，也可以重新赋值。
5、接口中的方法默认是public abstract类型的
（二）java抽象类和接口的相似之处：
1、不能实例化
2、都有为实现的方法声明
3、派生类必须实现未实现的方法，抽象类是抽象方法，接口是所有成员。

实现的单例是线程安全的方式

枚举、静态内部类、双检索模式、饿汉式。

Java多线程实现方式

主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。
其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。

参数传递问题（值传递与引用传递）

例子：

public class SendValue{
	public String str="6";
	public static void main(String[] args) {
		SendValue sv=new SendValue();
		sv.change(sv.str);
		System.out.println(sv.str);  //输出为6
	}
	public void change(String str) {
		str="10";
	}
}

解析：

java中的方法传递都是值传递，java中的数据类型有基本类型和引用类型，他们都是值传递方式。
基本类型传递的是它的值，因此方法中的改变参数的值，不会影响方法外。
引用类型传递的是一个地址，因为引用类型在生成对象实例时，里面的值是一个地址，指向了对象实例。在传值的时候实际上传的是一个地址，他们指向了同一块地址，所以在方法内的改变会影响方法外的参数。
这里比较乱人心的是包装类型，因为包装类型也是引用类型，这里应该就是和包装类型的实现有关了，在包装类型中，比如Integer a=1，有一个自动装箱的操作。其实a=1，如果现在令a=2，不会令2覆盖1（即1本身是不会变的），真正改变的是a被赋给了一个新地址，这个地址指向了2。因此方法内的改变包装类型的值就相当于改变了形参里面的地址，相当于重新new了一遍。而方法外面的实参仍旧指向含1的那个地址，一次方法内的改变不会影响方法外的实参。

public class SendValue{
	public String str="6";
	public static void main(String[] args) {
		SendValue sv=new SendValue();
		sv.change(sv.str);
		System.out.println(sv.str);  //输出为10
	}
	public void change(String str) {
		this.str="10";
	}
}

HttpServletResponse

HttpServletResponse完成：设置http头标，设置cookie，设置返回数据类型，输出返回数据；
读取路径信息是HttpServletRequest做的；

内部类

定义：可以将一个类的定义放在另一个类的定义内部。

class AA {
    //内部类
    public class Point {
        public int x = 1, y = 2;
    }
    //静态内部类
    public static class X11 {
    }
    //方法
    public Point getPoint() {
        return new Point();
    }
    //无返回值的方法
    public void printPoint() {
        Point point = new Point();
        System.out.println("point.x=" + point.x + ";point.y=" + point.y);
    }
    
    public static class InnerClass {

        public static void main(String[] args) {

            AA aa = new AA();
            aa.printPoint();
            //静态内部类实例化
            AA.X11 x11 = new AA.X11();

            //内部类实例化的声明类型可以打全路径名或者外部类.内部类的形式
            AA.Point point = aa.new Point();
            System.out.println("point.x="+point.x+";point.y="+point.y);

            AA.Point point2 = aa.new Point();
            System.out.println("point.x="+point2.x+";point.y="+point2.y);

            AA.Point point1 = aa.getPoint();
            System.out.println("point.x="+point1.x+";point.y="+point1.y);

            AA.Point point3 = aa.getPoint();
            System.out.println("point.x="+point3.x+";point.y="+point3.y);

        }
    }
}