盒子
盒子

Java基础小记

2017.04.11 Jenning Java  热度 ℃

1、常量用final定义，final修饰的类不能被继承，final修饰的方法不能被重写，final修饰的变量初始化以后不能被更改，且在定义final变量时一定要赋值，即初始化。

2、if-if和if-else if的区别: 前者两个if判断都会进行，后者第一个判断为false才会进行第二个判断。

3、反射：Class类保存着Java中的类型所有的信息,Class也是Java中的一个类，也需要实例化对象才可以调用里面的方法（静态方法除外）
1.获取Class类型的实例(对象)方法：

1
2
3
object.getClass()
Class.forName(className);
T.class //T是任意的Java类型,如Class cl = Date.class;

2.Class类常用方法：

1
2
cl.getName() //cl是Class类实例
cl.newInstance() //调用默认构造器（没有参数的构造器）初始化该Class对象所对应的类名的对象实例

4、Java父类引用指向子类对象:

1
Person a = new Man();

现象:
对象是在Java程序运行时才确定的（非编译阶段）
上面例子中，a可以调用Man类中覆盖父类的同名方法，而Man类中自己独有的方法，a是不能去调用的。（编译会报错，因为编译器认为a是一个Person对象，而Person类中找不到Man类独自定义的方法），当然，a也可以获取Person类中的属性和方法。而当Person类和Man类中有同名属性时，a.该属性获取到的是Person类（即父类）中的属性，而非Man类（即子类）中的属性。
因而可以得出结论:
1.属性是绑定类型的，而方法是绑定对象的。
2.或者说属性是在编译器就确认的，而方法是动态绑定（多态）。
在继承多态中：
1.对于方法的覆盖，new的谁就调谁，这就是多态。
2.对于成员变量的覆盖，this在哪个类就指向哪个类的成员变量，没有多态。
3.意思即是Java中public方法才有多态性，而属性是没有多态的。
4.对象调用编译时类型的属性和运行时类型的方法，即所谓的动态连接。

参考文档：
http://www.tuicool.com/articles/ZziiIjJ
http://blog.csdn.net/rockpk008/article/details/52374203
http://blog.csdn.net/kaiwii/article/details/8042488
http://blog.csdn.net/qq_23419401/article/details/52064871

5、Java方法的重载
Overloaded的方法是可以改变返回值的类型。
这句话是正确的，唯一区分方法重载的是方法的参数列表不同，当参数列表不同时就可改变其返回类型

1
2
3
4
5
6
public class OverLoadTest {
    public void m1(int x){}
    public int m1(int x,int y){return 12;}
    public String m1(int x){return "12";}//error! Duplicate method m1(int) in type OverLoadTest
    public String m1(int x,int y,int z){return "abc";}
    public int m1(String x,int y){return 12;};

结论：
1.当参数列表不同时，能达到区分重载时，就可以改变方法的返回类型，即重载主要表现在参数上面,当能够区分重载时才能去改变返回值类型.。
2.若只是返回值类型不一样是算不上重载的。重载的判断条件还是根据参数来看，只不过是说重载的函数可以返回值不一样，就是说重载可以决定返回值类型，但是返回值类型不能决定重载。

6、java source folder
source folder下面的Java文件都会被编译，编译后的文件会被放在我们设置的某个文件夹下面（一般我们设置成WEB-INF/classes）,source folder下面的非java文件会被copy一份放在我们的设置的文件夹下面。

7、Mybatis
核心: sqlSessionFactoryBuilder(构造器) -> sqlSessionFactory(工厂接口) -> sqlSession(会话)

8、操作符重载
定义：就是把已经定义的、有一定功能的操作符进行重新定义，来完成更为细致具体的运算等功能。操作符重载可以将概括性的抽象操作符具体化，便于外部调用而无需知晓内部具体运算过程。
String类是个特殊的类，对它的一些操作符是重载的，如：

1
2
3
String str = “Hello”; //等价于String str = new String(“Hello”);
String str = “Hello”;
str = str + “ world!”;//等价于str = new String((new StringBuffer(str)).append(“ world!”)); 此处str指向了一个新的内存空间

结论:
1.String对象和基本类型一样(但是StringBuffer类则不是)，一般情况下作为参数传递，在方法内改变了值，而原对象是不会被改变的。在Java中对象作为参数传递时，是把对象在内存中的地址拷贝了一份传给了参数。
2.Java都是通过引用来操作对象的，对象一般存储在堆(heap)中，而引用存储在速度更快的堆栈(stack)中。

9、static变量、static代码块
1.Class(即类)中的static变量在类被加载的时候static成员变量即被初始化，与类关联，只要类存在，static变量就存在。
2.当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。
3.被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
4.static方法中不能直接调用非static的变量，比如main方法中，不能直接调用该类的其他非static变量，而需要通过对象调用。

10、枚举类enum用法
1.常量:

1
2
3
public enum Color {
    RED,GREEN,BLACK,YELLOW
}

2.遍历、switch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public enum EnumTest {
    MON,TUE,WED,THU,FRI,SAT,SUN;
}
public class Test {
    public static void main(String[] args) {
        for(EnumTest e : EnumTest.values()) {
            System.out.println(e.toString());
        System.out.println("---");
        EnumTest test = EnumTest.TUE;
        switch(test) {
            case MON:
                System.out.println("Today is Monday");
                break;
            case TUE:
                System.out.println("Today is Tuesday");
                break;
            ...
            default:
                System.out.println("error");
                break;
        }
}
输出结果：
MON
TUE
WED
THU
FRI
SAT
SUN
---
Today is Tuesday

3.给enum自定义属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public enum EnumTest {
    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6) {
        @Override
        public boolean isRest() {
            return true;
        }
    },
    SUN(0) {
        @Override
        public boolean isRest() {
            return true;
        }
    };
    private int value;
    private EnumTest(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
    public boolean isRest() {
        return false;
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println("EnumTest.FRI 的 value = " + EnumTest.FRI.getValue());
    }
}
输出结果：
EnumTest.FRI 的 value = 5

4.原理分析
可以把enum看成是一个普通的class，它们都可以定义一些属性和方法，不同之处是：enum不能使用extends关键字继承其他类，因为enum已经继承了java.lang.Enum（java是单一继承）。

11、关于Session
1.Session是另一种记录客户状态的机制，不同的是Cookie保存在客户端浏览器中，而Session保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是Session。客户端浏览器再次访问时只需要从该Session中查找该客户的状态就可以了。
2、如果说Cookie机制是通过检查客户身上的“通行证”来确定客户身份的话，那么Session机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。
3、Session对应的类为javax.servlet.http.HttpSession类。每个来访者对应一个Session对象，所有该客户的状态信息都保存在这个Session对象里。Session对象是在客户端第一次请求服务器的时候创建的。Session也是一种key-value的属性对，通过getAttribute(String key)和setAttribute(String key, Object value)方法读写客户状态信息。
4、当多个客户端执行程序时，服务器会保存多个客户端的Session。获取Session的时候也不需要声明获取谁的Session。Session机制决定了当前客户只会获取到自己的Session，而不会获取到别人的Session。各客户的Session也彼此独立，互不可见。
提示：Session的使用比Cookie方便，但是过多的Session存储在服务器内存中，会对服务器造成压力。
5、由于会有越来越多的用户访问服务器，因此Session也会越来越多。为防止内存溢出，服务器会把长时间内没有活跃的Session从内存删除。这个时间就是Session的超时时间。如果超过了超时时间没访问过服务器，Session就自动失效了。
6、虽然Session保存在服务器，对客户端是透明的，它的正常运行仍然需要客户端浏览器的支持。这是因为Session需要使用Cookie作为识别标志。HTTP协议是无状态的，Session不能依据HTTP连接来判断是否为同一客户，因此服务器向客户端浏览器发送一个名为JSESSIONID的Cookie，它的值为该Session的id（也就是HttpSession.getId()的返回值）。Session依据该Cookie来识别是否为同一用户。该Cookie为服务器自动生成的，它的maxAge属性一般为–1，表示仅当前浏览器内有效，并且各浏览器窗口间不共享，关闭浏览器就会失效。因此同一机器的两个浏览器窗口访问服务器时，会生成两个不同的Session。但是由浏览器窗口内的链接、脚本等打开的新窗口（也就是说不是双击桌面浏览器图标等打开的窗口）除外。这类子窗口会共享父窗口的Cookie，因此会共享一个Session。
7、如果客户端浏览器将Cookie功能禁用，或者不支持Cookie怎么办？例如，绝大多数的手机浏览器都不支持Cookie。Java Web提供了另一种解决方案：URL地址重写。URL地址重写的原理是将该用户Session的id信息重写到URL地址中。服务器能够解析重写后的URL获取Session的id。这样即使客户端不支持Cookie，也可以使用Session来记录用户状态。HttpServletResponse类提供了encodeURL(String url)实现URL地址重写,该方法会自动判断客户端是否支持Cookie。如果客户端支持Cookie，会将URL原封不动地输出来。如果客户端不支持Cookie，则会将用户Session的id重写到URL中。

12、Java异常
1.设计异常处理 本来就是为了不可控制的异常 不去影响程序的流程
2.能捕捉到的异常,将之处理了,就不进行抛出了.处理不了,继续往该异常的上一层异常调用的地方抛出,直到解决.
3.try{}里面包含可能会出错的代码，如果里面出错了，它会交给catch{}处理，catch可能把这个错误给屏蔽掉（就比如说你牙疼不能吃饭，来个止疼的药片，不影响你做其他的事情了）。不影响你之后的代码运行。但是如果你try{}里面有多行代码第一行，第二行，第三行，如果第二行出错了，第三行是不执行的。如果有finally{}这里面代码是处理后事的。比如说，你try里面有操作工作流的，那么如果出错了fianlly可以用力处理，关闭工作流对象，避免浪费资源。`finally{}是必须执行的，不管是出错了，还是不出错。

Welcome
欢迎来到Jenning's blog