JAVA $ JSP

1. java中数据类型分为两种
   基本数据类型：数值型，字符型，布尔型
   引用数据类型：类，接口，数组
   
   

基本数据类型所占空间固定，有别与C++，java中没有无符号数
byte:1字节
short：2字节
char:2字节，java采用unicode编码
int:4字节
long:8字节    long l = 3l;
float：4字节  申明浮点类型变量并复制  float f = 3.14f;  因为默认浮点数为doble,整型数为int
double：8字节
boolean：只能取值为true或false,不能以0或非0的数值代替


2. 标识符
一般类名大写，包名、方法名、变量名小写，少用下划线

3. 运算符
java中多了个无符号右移运算符 >>>  ，最高位为在右移会补0
对于int型数据移位a>>b,系统先将b对32取模，得到得结果才是真正的移位的位数，long型则对64取模

+运算符中两侧的操作数只要有一个是字符串类型（String），系统就会自动将另外一个操作数转换为字符串然后进行连接
int i = 9;
Srting s = "helo" + i + "号";

4. 语句
   java中没有表达式语句这个概念：  x+y;这条语句是不合法的    
   java中switch 语句中的表达式可以使字符，数字和 字符串 类型
   java中没有goto，但是可以break和continue后加标号实现类似功能，但是break只能从里层循环跳到外层循环

   定义java数组 int [] a = new int[3];int a[] = new int[3]; int a[] = {1,2,4};
   int a[5];//非法，因为java中数组是引用类型，a在这里只是一个引用
   Array.copy(source,0,dest,0,source.Length);提供了数组元素复制功能

   int [][]a = new int [3][];
   a[0] = new int[4];
   a[1] = new int[5];
   a[2] = new int[3];
   

5. 构造
   java中可以使用this在构造函数中调用自己的另外一个构造方法，或者super调用父类的构造方法，这条调用语句必须放在第一句，且只能够有一条，在C++中则不能
   如果没有super，java类中构造函数内部会自动加上super调用相应的构造函数

   针对没有相应构造函数，但又要赋值在java可以用双括号这样写
   Person p = new Person(){{age = 18;name = "李明"}};

6. 派生子类
   java中的继承是使用extends关键字来实现的
   如果没有extends子句，则该类默认为java.lang.Object的子类，所有的类都是直接或者间接地继承java.lang.Object得到的
   class A extends B{};
   
   需要明确使用父类的属性和方法时使用super关键字

7. 包
   包及子包的定义实际上是为了解决名字空间，名字冲突
 
   包有两层含义：一是名字空间、存储路径（文件夹）；一是可访问性（同一包中的各个类，默认情况下可相互访问）
   
   包层次的根目录是由环境变量CLASSPATH来确定的
   
8. import语句
   import用来导入所需要的类
   例如：
   import java.util.Date;
   import java.awt.*
   import java.awt.event.*    //使用*号只能表示本层次的所有类，不包括子层次下的类


9. 访问控制
   定义类时也可以使用访问控制符，如果使用public控制符，则该类可以被其他所有类访问，若使用默认控制符，
   则只可以被同包中的类访问

10. final修饰符
    final类不能被继承，无子类
    final方法不能被子类覆盖
    final字段及final局部变量的值一旦给定就不能修改，是只读变量，只能被赋值一次
    一个字段被static final两个修饰符限定时可以表示常量

11. java中有抽象类和抽象方法，使用abstaact修饰
    抽象类可以包含抽象方法，也可以不包含，但是一旦某个类中包含了抽象方法，这个类必须申明为抽象类
    抽象方法在子类中必须实现，否则子类仍然是抽象的。

12. 接口
    接口中定义的变量为常量，省略了public,static,final
    默认接口中的方法为public,在接口的实现中应该写出来
    接口中的方法都是默认方法
    java8以上可以有static方法就不是抽象了，还可以有具有实现体的方法（默认方法）
    接口可以多继承其他接口，类再实现接口，就可以实现多继承了

    //接口中的变量为public static final类型，函数public abstract类型，不管你写不写
    interface Inter{
        public static final int AGE = 100;
        public abstract void tell();
    }

13. 原文件名必须与属性为public的类名完全相同，在一个.java文件中package语句和public类最多只有一个

14. 字段变量和局部变量
    java中属性或者成员变量为字段变量，方法中的变量或者参变量为局部变量，字段变量属于类。
    存储位置：成员变量存储在堆中的对象里面，局部变量的数据存储在栈类型中。
    初始值：字段变量可以自动赋值，局部变量则可以显式赋值。
    局部变量必须初始化，一般的成员变量可以不初始化。
    
14.1 java变量的存储位置和区别
    寄存器：由编译器根据需求分配，我们无法再程序中控制
    栈：存放基本类型的变量数据和对象引用，但对象本身不放在栈中，而是存放在堆中（new出来的对象）或者
        常量池中（字符串常量对象存放在常量池中）
    堆：存放左右new出来的对象
    静态域：存放静态成员（static定义的）
    常量池：存放基本类型常量和字符串常量
    
    栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。
    堆中的对象由垃圾回收器负责回收。
    栈和常量池中的对象可以共享，堆中的对象不可共享。
    
    

15. 多态和虚方法调用
    java中的类类型是引用，里面的普通方法都是虚方法，根据实例调用相应的方法实现多态，C++中必须加virtual关键字
    static与实例无关，private,final方法不会被虚化

    动态类型确定运算符instanceof，返回值为true，false
       for(int i = 0;i < objs.length;i++){
            if(objs[i] instanceof Integer){
                s += ((Integer)objs[i]).intValue();
            }
            else{
                if(objs[i] instanceof Double)
                    s += ((Double)objs[i]).doubleValue();
            }
        }


16. 垃圾回收
    System.gc()方法可以请求系统进行垃圾回收
    java中finalize方法类似于其他语言的析构方法，系统在回收时会自动调用对象的finalize方法


17. 内部类
    在内部类中可以直接访问外部类的字段和方法，即使private也可以
    如果内部类中有与外部类同名的字段和方法，则可以用  外部类名.this.字段或方法
    拥有内部类的外部类只能使用public修饰或者默认

    用static修饰内部类，表明该内部类实际是一种外部类，因为它与外部类实例无关，static类不能访问其外部类的非static的字段及方法，只能够访问static成员，static方法中也不能访问非static的域及方法

内部类的使用方法
class A{
    class B{
        
    }
}

class C{
    static class D{
        
    }
}

public class mo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        A a = new A();
        A.B b = a.new B();
        A.B a_b = new A().new B();
        
        C.D d = new C.D();//right
//        C.D d = C.new D();//error
//        C.D d = new c().new d();//error
    }
}


18. 局部类
    同局部变量一样，方法中的内部类，不能使用public,private,protected,static修饰，但是可以被final或者abstract修饰
    可以访问其外部类成员，不能够访问该方法的局部变量，除非是final局部变量

19. 匿名类
    不取名字，直接使用父类或者接口的名字
    也就是说该类是父类的子类，或者实现了一个接口
    编译器生成XXXX$1之类的名字

    类定义的同时就创建实例，即类定义前面有一个new
    不使用关键词class，extends，implements等

    在构造对象时使用父类的构造方法
    不能够定义构造方法，因为它没有名字
    如果new对象时需要参数，则使用父类的构造方法

20. Lambda表达式
    能写成Lanbda的接口要求包含且最多只能有一个抽象函数


21. 装箱和拆箱
    Integer I = 10;//装箱，可以直接赋值，将基本类型包装为Object（引用类型）
    等同于：
    Integer I = Integer.valueOf(10);
    int i = I;//拆箱，直接赋值，将引用类型转换为基本类型
    等同于：
    int i = I.intValue();

    Object []ary = {1, "aaa"};//其中1就被装箱了

22. 自定义枚举

23. 注解
    又称为注记、标记、标注、注释（不同于commnets）
    是在各种语法要素上加上附加信息，以供编译器或者其他程序使用
    所有的注解都是java.lang.annotation.Annotation的子类
    
    常用注解
    @Override  表示覆盖父类方法
    @Deprecated 表示过时的方法
    @SuppressWarnings  表示让编译器不产生警告
    
    自定义注解：


24. 装箱是否相等
    使用 == 进行判断时基本类型可以直接判断，引用类型得看引用得对象是否相同
    Integer i = new Integer(10);
    Integer j = new Integer(10);
    Sysytem.out.println(i == j);//false,，因为对象时是两个

    Integer i = 10;//实际上使用了valueOf()函数，这个函数给-128-127的数进行了缓存
    Integer j = 10;
    Sysytem.out.println(i == j);//true,，因为对象有缓存

    Integer i = 220;
    Integer j = 220;
    Sysytem.out.println(i == j);//false,，因为对象是两个

    基本类型缓存的范围
    true,false,byte,char \u0000 - \u007f
    int,short -128-127
    在缓存范围内装箱的对象时相等的
 

25. 枚举，引用对象是否相等
    枚举类型内部进行了唯一实例化，所以可以直接判断

    引用对象：如果要判断内容是否相等，则要重写equals方法，如果重写equals方法，则最好重写hashCode方法
    
    String对象，判断相等一定不要用==，要用equals
    字符串常量可以直接用 == 比较，字符串常量被内部化了interned，有点像整数的包装
    String hello = "Hello",lo = "lo";
    System.out.println(hello == "Hello");//true
    System.out.println(mo.ot == "Hello");//true
        
    System.out.println(hello == ("Hel"+"lo"));//true，编译器已经把它合成为“Hello"
    System.out.println(hello == ("Hel"+lo));//false,和变量相加不会合成字符串常量
        
    System.out.println(hello == new String("Hello"));//false
    System.out.println(hello == ("Hel"+lo).intern());//true

26. finally
    finally语句无论是否有异常都要执行，即使其中有break，return语句


27. Eclipse调试java
    F5 逐语句执行
    F6 逐过程执行
    F7 跳出函数
    Ctrl+R 运行到光标处

    监视
    即时监视：鼠标指向变量
    快速监视：点右键，Inspector
    添加监视：点右键，Watch

    还可以看调用堆栈


28. 常用的方法(Object)
    equals()  //判断内容是否相同， ==  是判断引用是否相等，一般重载了 equals方法也会重载hashCode方法
    getClass() //final方法，返回一个对象在运行时所对应的类的表示
    toString()  //返回对象的字符串表示
    finalize() //对象清除
    
    与线程相关
    notify()
    notifyAll()
    wait()


29. 基本类型对应的包装类
    Character，Byte,Short,Integer,Long，Float，Double,Boolean

    包装类的特点
    1）提供了一些常数：
    如Integer.MAX_VALUE(整数)，Double.NaN(非数字)，Double.POSITIVE_INFINITY(正无穷)
    2）提供了valueOf(String),toString():用于从字符串转换或转换为字符串
    3）通过xxxxValue方法可以得到所包装的值：如Integer对象的intValue方法
    4）对象中包装的值是不可改变的，要想改变对象的值的只能重新生成对象
    5）toString(),equals()方法进行了覆盖
    除了以上特点有些类还提供了一些实用的方法以方便操作：如Double类提供了parseDouble(),max,min等
    

30. 创建线程的两种方法
    1)通过继承Thread类创建线程
    class MyThread extends Thread{
        public void run(){
        }
    }

    2）通过Thread()构造方法传递Runnable对象来创建线程
    class MyTask implements Runnable{
        public void run(){
        }
    }
    Thread thread = new Thread(mytask);
    thread.start();

    3)使用匿名类来实现Runnable
    new Thread(){
        public void run(){
        }
    }
   
    4)使用Lambda表达式
    (new Thread()->{}).start();

31. 线程相关的方法
    start()  //启动线程
    run()    //run函数结束线程结束
    setPriority(int priority)  设定线程的优先级
    setDeamon(true)   //设置守护进程，主线程结束deamon线程也会结束

32. 同步
    互斥锁
    关键字synchronized用来与对象的互斥锁联系
    synchronized的用法
    1）对代码片段
    synchronized(对象){...}
    2）对某个方法
    放在方法申明中
    public synchronized void push(char c){...}

33. 输入输出流
    字节流与字符流
    字符流：Reader,Writer
    字节流：InputStream,OutputStream

    重要方法：    
    InputStream：read()  //读取的是字节
    OutputStream:write(),flush() //刷新缓存，实际写入到文件、网络,close() //关闭流
    Reader:read() //读取的是字符
    Writer：write() //写入的是字符

34. 节点流和处理流
    节点流：可以从一个特定的地方读写数据，如文件流FileInputStream,内存流ByteArrayInputStream
    处理流：是对一个已存在的流的连接和封装，又称为过滤流，如缓冲处理流BufferedReader

35. 标准的输入和输出
    System.in 为InputStream类型
    System.out 为PrintStream类型
    System.err 为PrintStream类型

    从标准输入读取数据：
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    br.readLine();

36. Scanner类从控制台获取数据
    String next()   //接收控制台输入的一个字符
    String nextLine()   //接收控制台输入的一个字符串
    int nextInt()    //接收控制台输入的一个int型数据
    double nextDouble()  //接收控制台输入的一个double数据
    boolean nextBoolean()   //接收控制台输入的一个boolean数据

    例子：
    Scanner scanner = new Scanner(SYstem.in);   //尽量直接避免在控制台输入中文

37. 引用传递
    java里面只有基本类型是按值传递，比较特殊是String类的对象因为无法更改，出现更改时实际上是生成了新的String对象，可以把String类型看成按值传递


38. 泛型
    泛型作为函数参数时有两种方式，一种是不指定类型
    class Info<T>{};
    class Demo{
        public void fun(Info i){
        }
    }
    
    一种是使用通配符，且使用通配符比较多
   class Demo{
        public void fun(Info<?> i){
        }
    }

    除了类之外接口也可以定义为泛型




39. jsp注释
    <%--    --%>


40. jsp编译指令

50. JDBC编程的五个步骤
    加载驱动->打开连接->执行查询->处理结果->清理环境


Eclipse快捷键及配置
Alt + /       //代码提示，补全名称

在项目代码里面右键进入preference是配置本项目选项，windows->preference是设置全局的
代码提示设置
eclipse默认只有 . 号后有代码提示，可以在preference—>java->Editor->Content Assist中设置出现其他字符时也提示
代码字体设置
进入preference—>General->Appearence->color and Fonts，右边选择java->java Editor Text Font，可以设置字体和大小，其他以此类推

查看并修改eclipse预定义的快捷键
preference—>General->Editor->keys


ctrl + /      //注释选中的代码或者光标所在的行
输入 /** 回车后可以自动创建java doc注释，如果下面是函数的话，可以自动生成参数和返回值的java doc信息

输入syso后 再用名称补全 可以得到 System.out.println(); ,syse可得System.err.println();

ctrl + 1快捷修复
例如：int i = 100L;  //将鼠标放在出错的行使用 ctrl + 1 可以弹出修复选项，也可以悬停在错误处直接弹出
F2 也可以快捷修复

ctrl + d      //删除选中的代码或者光标所在的行
Shift + Enter   //在光标所在行的下一行迅速创建新的一行，对于某行代码比较长需要换行是比较实用
tab           //将光标自动缩进到当前行代码的正确位置
Ctrl + F11    //快速运行代码
Alt + ↑或↓    //快速上下移动选中的代码或者行
Ctrl + Alt + ↑或↓    //快速上下复制选中的代码或者行
Ctrl + m      //将光标所在的eclipse视图最大化，再按一次可还原
Shift + Ctrl + F  //自动排列选定的代码格式



需要搞清楚的问题：
1. java里面各种数据类型的数据的生命周期和初始化顺序以及存储位置

2. JNI (java Native Interface)

3. java中的比较，hashCode方法时怎么回事

4. java成员函数中不能定义静态变量

5. java的集合

转载于:https://www.cnblogs.com/Mr-Zhong/p/5098199.html