javaweb笔记全套

时间 2019-11-13

标签 javaweb 笔记全套栏目 Java 繁體版

原文原文链接

Lesson 1

1、eclipse工具的使用

1. java代码的位置

1) 选择工做空间 workspace 选择一个文件夹存放程序(代码) 不要用中文和空格javascript

2) 新建一个java 工程(Project)css

3) 建包建类html

2. 快捷键

alt + / ：代码自动补齐，须要配置的java

打开preferences(首选项), 搜keys，打开快捷键配置面板mysql

搜 alt+/ ，取消绑定程序员

搜 content assist ，取消原先的绑定，配置成alt+/web

ctrl+1: 错误自动修复，注意，放行的红叉是可修复的，圆形的是不可修复的面试

导包的三种方式：ajax

1）将类名敲完整，按下alt+/ 进行补齐，会自动导包算法

2) ctrl+1,修正错误

3) ctrl+shift+o 整理包，导入须要的包，去掉多余的导包语句

ctrl+shift+f : 代码格式化

ctrl+2,L 自动声明变量

shift+enter 光标直接进入下一行

ctrl+alt+方向键(向上向下) 复制行

alt+ 方向键(向上向下) 移动当前行

3. 断点调试

1) 能够对程序进行调试

在行的开头双击左键打断点，用debug方式来运行程序，程序就会停留在断点位置

F5 跳入(step into) 跳入方法内部 F6 跳过，让当前行运行 F7跳出返回上一层程序

resume 直接运行到下一个断点

2) 查看源代码建议使用断点调试的方式，注意当前运行环境须要包含源码

4. junit单元测试

1) 写一个java类，声明测试方式

修饰符为 public void ,

在方法前面加注解，(@Test)

此方法就能够进行测试了(交给junit运行)

2) 须要在测试方法前作初始化工做

写一个静态方法 public static void init()

在方法前加注解 @BeforeClass

3) 须要在测试后释放资源

写一个静态方法

在方法前加注解 @AfterClass

2、jdk5新特性

1. 静态导入

1) 导入类的静态属性

import static java.lang.System.out;

out.println("haha");

2) 导入类的静态方法

import static java.lang.Math.*; // 导入Math类的全部静态成员

int num = abs(-10);

2. 加强for循环

1) 做用：对存储对象的容器进行迭代

2) jdk5之前怎么迭代

3) 加强for循环迭代数组

String [] arr = {"a", "b", "c"}; //数组的静态定义方式，只试用于数组首次定义的时候

// 传统方式

for(int i=0; i<arr.length; i++) {

// i依次表示数组的角标

String s = arr[i];

System.out.println(s);

}

System.out.println("-------------------------------------");

// 在jdk5中咱们可使用加强for循环迭代

// 加强for循环括号里写两个参数，第一个是声明一个变量，变量类型必须是数组元素的类型

// 第二个就是须要迭代的容器

// for循环会循环容器的length次, 每次都将容器的第n-1个元素赋值给声明的变量

for(String s : arr) {

// 循环体，执行arr.length

// 每次都将arr中的第n-1个元素给s

System.out.println(s); //

}

3. 基本数据类型的包装类

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

1) Integer x = 1; x = x + 1; 经历了什么过程？装箱à 拆箱 à 装箱

2) 为了优化，虚拟机为包装类提供了缓冲池， Integer池的大小 -128~127 一个字节的大小

3) String池

Java为了优化字符串操做提供了一个缓冲池

面试题：

String s = “abc” 和 String s = new String(“abc”) 的区别

String s = new String(“abc”) 建立了几个对象

String s = “a” + “b” + “c” + “d” 建立了几个对象

String s1 = “a” String s2 = “b” String s3 = s1 + s2; s3==”ab”?

/*1. String s = "abc"，虚拟机首先会检查String池里有没有"abc"对象(经过equals方法)

// 若是有，直接返回引用，若是没有，会在池里建立一个“abc”对象，并返回引用

String s1 = "abc";

String s2 = "abc";

System.out.println(s1==s2); // result: true

/* 2. String str = new String("abc");

无论缓冲池是否有"abc", 都会在堆内存建立一个"abc"对象，返回引用

// 此时，负责检查并维护缓冲池，其实堆内存的对象是缓冲池中"abc"对象的一个拷贝

String s1 = new String("abc");

String s2 = new String("abc");

System.out.println(s1==s2); // result: false

/* 3. String s = "a" + "b" + "c" + "d"; java编译器有个合并已知量的优化功能

// 在编译阶段就把"a" + "b" + "c" + "d" 合并为 ”abcd“

String s = "a" + "b" + "c" + "d";

// String s = "abcd";

System.out.println(s=="abcd");// result: true

/* 4. String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;

// String是常量，不能相加的，java如何实现的？

StringBuilder sb = new StringBuidler(s1);

sb.append(s2);

s3 = sb.toString();

也就是说实际上s3是方法返回的String对象

凡是方法返回的字符串对象都是在堆内存的

String s1 = "a";

String s2 = "b";

String s3 = s1 + s2; // 堆内存的对象

System.out.println(s3=="ab");// result: false

4) 单列集合 Collection

List list = new ArrayList();

list.add("aaa");

list.add("bbb");

list.add("ccc");

// 传统方式1

/* 1.得到迭代器

Iterator iter = list.iterator();

// 2.循环判断迭代器是否有下一个

while(iter.hasNext()) {

String str = (String) iter.next(); // 将迭代器的指针移向下一个，并将迭代当前指向的元素返回

System.out.println(str);

}

// 传统方式2

for(Iterator iter=list.iterator(); iter.hasNext(); ) {

String s = (String) iter.next();

System.out.println(s);

}

System.out.println("--------------------------------");

// 加强for循环, 没有使用泛型的集合能不能使用加强for循环迭代？能

for(Object obj : list) {

String s = (String) obj;

System.out.println(s);

}

5) 双列集合 Map

Map map = new HashMap();

map.put("a", "aaa");

map.put("b", "bbb");

map.put("c", "ccc");

// 传统方式迭代1

// 1. 得到全部的key

Set keys = map.keySet();

// 2.迭代keys得到全部的key

Iterator iter = keys.iterator();

while(iter.hasNext()) {

String key = (String) iter.next(); // a b c

// 3.根据key得到对应的value

String value = (String) map.get(key);

System.out.println(key + "=" + value);

}

System.out.println("---------------------------------");

// 传统方式2，必须掌握这种方式

// 1.得到全部的键值对Entry对象

Set entrys = map.entrySet();

// 2.迭代出全部的entry

iter = entrys.iterator();

while(iter.hasNext()) {

Map.Entry entry = (Entry) iter.next();

// 分别得到key和value

String key = (String) entry.getKey();

String value = (String) entry.getValue();

System.out.println(key + "=" + value);

}

System.out.println("-------------------------------------");

System.out.println("加强for循环迭代，");

// 加强for循环迭代，

// 原则上map集合是没法使用加强for循环来迭代的，

// 由于加强for循环只能针对实现了Iterable接口的集合进行迭代

// Iterable是jdk5中新定义的接口，就一个方法iterator方法

// 只有实现了Iterable接口的类，才能保证必定有iterator方法

// java有这样的限定是由于加强for循环内部仍是用迭代器实现的

// 而实际上，咱们能够经过某种方式来使用加强for循环

for(Object obj : map.entrySet()) {

// obj 依次表示Entry

Map.Entry entry = (Entry) obj;

System.out.println(entry.getKey() + "=" + entry.getValue());

}

6）集合迭代注意问题

// 在使用迭代器迭代集合的过程当中，不能对集合进行增删操做

@Test

public void test4() {

List list = new ArrayList();

list.add("wangwu");

list.add("zhangsan");

list.add("lisi");

Iterator iter = list.iterator();

while(iter.hasNext()) {

String name = (String) iter.next();

if("wangwu".equals(name)) {

// 从集合中删掉

//list.remove(name);

// 迭代过程当中删除元素须要调用迭代器的方法

iter.remove(); // 删除我迭代的集合被我迭代的最后一个元素

}

// 1 2 4

System.out.println(list.size());

}

@Test

public void test5() {

List list = new ArrayList();

list.add("aa");

list.add("bb");

// 使用ListIterator迭代器

ListIterator listIterator = list.listIterator();

while(listIterator.hasNext()) {

listIterator.next();

// 迭代过程当中增长元素

listIterator.add("cc");

}

System.out.println(list.size());

}

7) 加强for循环注意问题

//在使用加强for循环时，不能对元素进行赋值

int[] arr = {1,2,3};

for(int num : arr) {

num = 0;

}

System.out.println(arr[1]);

4. 可变参数

1) jdk5中方法的形参能够定义为可变参数，传入实参个数可变

// 设计一个方法求n个数的和

public static int getSum(int... arr) {

// 可变参数在方法中仍被看作一个数组

int sum = 0;

for(int num : arr)

sum += num;

return sum;

}

2)Arrays.asList为例演示传入不一样参数的状况

// list长度为3

List list = Arrays.asList("a","b","c");

// list长度为1，由于考虑1.4语法

String[] arr = {"a","b","c"};

List list = Arrays.asList(arr);

// 同时符合1.4和1.5的语法,此时会优先考虑1.4的语法

// 缘由是有了新功能要保证之前的代码不出错，向后兼容

// 如今就须要将arr做为一个元素存入集合

Object obj = arr;

List list2 = Arrays.asList(obj); // 此时只符合1.5的语法，不符合1.4的语法，没有歧义

List list3 = Arrays.asList(new Object[]{arr}); // 优先考虑1.4，因此数组会拆开

//System.out.println(list3.size());

// 基本数据类型数组只符合1.5的语法

int[] nums = {1,2,3};

list = Arrays.asList(nums);

System.out.println(list.size());

5. 枚举

问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个

解决办法：

1）在setGrade方法中作判断，不符合格式要求就抛出异常

2）直接限定用户的选择，经过自定义类模拟枚举的方式来限定用户的输入

写一个Grade类，私有构造函数，对外提供5个静态的常量表示类的实例

3) jdk5中新定义了枚举类型，专门用于解决此类问题

4) 枚举就是一个特殊的java类，能够定义属性、方法、构造函数、实现接口、继承类

//枚举类就是一个java类，也能够声明属性，方法，构造函数

public enum Grade4 {

A("90-100"),B("80-89"),C("70-79"),D("60-69"),E("0-59");

private String value;

private Grade4(String value) {

this.value = value;

}

public String getValue() {

return value;

}

//枚举类就是一个java类, 也能够继承抽象和实现接口

public enum Grade5 {

// 抽象类不能建立实例对象

A("90-100"){

// new了一个Grade5的子类实例