问科研项目
主要是解决什么问题
>>和>>>
移位操作符只能处理整数类型。
int类型占4个字节（一共32位），第一位表示符号位，其它位为数值为。那么它最大能表示2^31-1（即2147483647），最小能表示-2^31(即-2147483648)。
为什么最小值不是-2^31-1，而是-2^31？
- 负数在计算机中以补码表示（符号位不变，原码取反再加1），因此10000000 00000000 00000000 00000000表示最大的负数，为-2^31。
1
2
3
4
| System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.toBinaryString(-2147483648));
System.out.println(Integer.toBinaryString(-1));
|
移位操作符有以下几种（注意：移位时符号位也会跟着移动）：
- 左移位操作符<<，低位补0
- 有符号右移位>>，使用符号扩展：若符号为正，则在高位插入0；若符号为负，则在高位插入1
- 无符号右移位>>>，使用零扩展：无论正负，都在高位插入0
如果对char、byte、short类型移位，则在移位前，它们会被转成int类型，且返回值也是int类型；如果对long类型移位，则返回值也是long。
finally和finalize
（1）finally：搭配try-catch一起使用，正常情况下，不管是否抛出异常或者捕获异常，finally都会执行。
什么是否finally不执行：在try中调用System.exit(1)或者halt函数时不执行，
以下两种情况要清楚：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| package com.company;
public class Main {
static String test(){
try {
System.out.println("123");
throw new Exception();
} finally {
System.out.println("finally");
}
}
public static void main(String[] args) {
System.out.println(test());
}
}
|
上面代码抛出异常。
但finally语句return后就不会抛出异常了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class Main {
static String test(){
try {
System.out.println("123");
throw new Exception();
} finally {
return "finally";
}
}
public static void main(String[] args) {
System.out.println(test());
}
}
|
程序正常，输出：
覆盖其他返回语句：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class Main {
static String test(){
try {
System.out.println("123");
return "try";
} finally {
return "finally";
}
}
public static void main(String[] args) {
System.out.println(test());
}
}
|
结果为：
改变throw或return行为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class Main {
static String test(){
try {
System.out.println("123");
return "try";
} finally {
throw new Exception();
}
}
public static void main(String[] args) {
System.out.println(test());
}
}
|
结果为：
try代码中没有异常，可以正常返回，。但在fianlly中抛出异常
（2）finalize
是Object类提供的方法，Java中的垃圾回收机制在回收对象的时候，会首先调用该对象的finalize方法，
1
| protected void finalize() throws Throwable { }
|
具体使用：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| public class FinalizeDemo01 {
public static void main(String[] args) {
for (int j = 0; j < 100000; j++) {
Person person = new Person();
person=null;
System.gc();
}
}
}
class Person{
@Override
protected void finalize(){
System.out.println("对象即将被销毁");
}
}
|
输出：”
1
2
3
4
5
6
7
8
9
| 对象被销毁
对象被销毁
对象被销毁
对象被销毁
对象被销毁
对象被销毁
对象被销毁
对象被销毁
。。。。。。
|
内部类的作用和声明方式
内部类作用：内部类使得多继承的解决方案变得更加完整（也就是内部类可以实现多继承），每个内部类都能独立继承一个实现，所以无论外围类是否已经继承了某个实现，对于内部类都没有影响。
内部类的特性：
- 内部类的对象与外围对象相互独立
- 多个内部类可以以不同的方式实现同一个接口或继承同一个类
- 内部类提供了更好的封装，除了外围类，其他类不能访问，。
内部类分为：成员内部类、静态内部类、局部内部类、匿名内部类
（1）成员内部类
让内部类可以访问外部类中定义的一个私有的msg属性的内容。内部类有一个最大的优点：可以访问外部类中的私有操作。
内部类可以访问外部类的私有属性，反之，外部类可以通过内部类对象访问内部类的私有属性
注意：
- 成员内部类不能有任何static的变量和方法
- 成员内部类是依附于外围类的，所以只有 先创建外围类才能创建内部类
例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Outer{
private String msg = "hello world";
class Inner{
public void print(){
System.out.println(Outer.this.msg);
}
}
public void fun(){
new Inner().print();
}
}
public class TestDemo{
public static void main(String args[]){
Outer out = new Outer();
out.fun();
}
}
|
实例化：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Outer{
private String msg="hello world";
class Inner{
public void print(){
System.out.println(Outer.this.msg);
}
}
}
public class TestDemo{
public static void main(String args[]){
Outer.Inner oi = new Outer().new Inner();
oi.print();
}
}
|
如果内部类定义为private，则内部类不能在外部进行对象的实例化。
（2）静态内部类
使用static定义的属性或者方法是不受类实例化对象控制的，所以使用了static定义内部类。不受外部类实例化对象的控制。
如果一个内部类使用了static定义的话，那么这个内部类就变为了一个外部类，并且只能访问static定义的操作。相当于定义一个外部类。
注意：
- 它的创建是不需要依赖于外部类
- 它不能使用任何外部类的非static成员变量和方法
例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Outer{
private static String msg="Hello World";
static class Inner{
public void print(){
System.out.println(msg);
}
}
}
public class TestDemo{
public static void main(String args[]){
Outer.Inner oi = new Outer.Inner();
oi.print();
}
}
|
（3）局部内部类
它是嵌套在方法和作用于内的，它只能在该方法和属性中被使用，出了该方法和属性就会失效。
例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| class Outer{
private String msg = "Hello World";
public void fun(int num){
double score = 99.9;
class Inner{
public void print(){
System.out.println("属性" + Outer.this.msg);
System.out.println("方法参数：" + num);
System.out.println("方法变量：" + score);
}
}
new Inner().print();
}
}
public class TestDemo{
public static void main(String args[]){
new Outer().fun(100);
}
}
|
（4）匿名内部类
匿名内部类是没有访问修饰符的，没有构造方法的。
例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class TestDemo{
public static void main(String args[]) throws Exception{
fun(new IMessage(){
public void print(){
System.out.println("匿名内部类");
}
});
}
public static void fun(IMessage msg){
msg.print();
}
}
|
是否了解设计模式
redis持久化
@Autowired作用
还有一些不记得了~~