1、myeclipse安装和使用(**)

2、debug调试模式(**)

  - F6: 单步执行

  - F8:结束断点,后面有断点到下一个断点

3、myeclipse快捷键(**)

4、junit单元测试(**)

  @Test

5、泛型在集合上的应用(********)

6、自定义泛型方法和泛型类(**)

  重点掌握泛型方法(*******)

  两个练习(********)

7、枚举的由来(了解)

8、特殊的枚举(了解)

=======================================================

9、枚举的api(了解)

10、静态导入(了解)

11、自动拆装箱(*******)

  装箱和拆箱

  在jdk1.4里面如何实现装箱和拆箱

  jdk的向下兼容概念

12、增加for循环(*******)

  语法格式

  增强for应用场景

  增强for出现的目的:替代迭代器

  增强for循环底层的实现是迭代器

13、可变参数(*******)

  写法 int...nums

  可变参数应用场景

  逻辑相同,传递参数不同

  注意的几个地方

14、反射的原理(***理解****)

15、反射的使用(***会写****)

  (1) 获取类中的构造方法(无参数)

  (2) 获取类中的构造方法(参数)

  (3) 获取类中的属性

  (4) 获取普通方法

1、myeclipse的安装和使用

  eclipse:是一个免费的开发工具

  myeclipse:是一个收费的插件,破解myeclipse,

    安装目录的要求: 不能有中文和空格

    安装完成之后,选择一个工作空间 ,这个工作空间不能有中文和空格

  破解myeclipse

    运行run.bat文件,但是运行之前,必须要安装jdk,通过配置环境变量

  myeclipse的使用

  创建一个工程

    - 类型 java project  web project

    - 选择依赖的jdk,可以使用myeclipse自带的jdk,或者可以使用安装的jdk

  创建包 package

    - cn.itcast.test  XX.XX.XX

  在包里面创建一个类

    - 类的命名规范:

      首字母要大写

        比如: TestDemo1  UserManager

  在类里面创建方法

    public void test1(参数列表) {

      方法体或者返回值;

    }

    - 方法的命名规范

      首字母小写  比如:addNum()

    定义变量

      - 变量的命名规范

      首字母小写,第二个单词的首字母要大写 ,比如 userName

    这些命名还有一种方式

      使用汉语拼音命名 yonghuming mima

      不能把汉语拼音和英文字母混合使用

        userMing

    命名的最基本的原则:看到名字知道是什么含义

    代码需要有缩进

    运行程序  Run As >> java application

          debug as  java application

2、debug的调试模式(断点调试模式)

  使用这种模式,调试程序(看到程序里面数据的变化)

  使用debug第一步需要设置一个断点(让程序运行停止在这一行)

    - 显示出来行号

    - 双击左边,出现一个圆点,表示设置了一个断点

  使用debug as方式,运行程序

    - 提示是否进入到调试界面,yes

    - 在断点那一个,有一个绿色条,表示程序停止在这一行,没有向下运行

  可以让程序向下执行,

    - 使用 step over 快捷键是 F6(单步执行)

    - resume F8:表示调试结束,直接向下运行

      比如当前的断点之后还有断点,跳到下一个断点,

      如果当前断点后面没有断点,程序直接运行结束

  debug另外一个用途

    查看程序的源代码

    F5 step into:进入到方法

    F7 step return :返回

3、myeclipse的快捷键的使用

  代码提示 alt /

代码修复 ctrl 1

   快速导包 ctrl shift o

  单行注释 ctrl /

  去掉单行注释 ctrl /

  多行注释 ctrl shift /

  去掉多行注释 ctrl shift \

  删除行 ctrl d

代码的格式化 ctrl shift f

查找 ctrl f

ctrl + o 显示当前类中所有方法的列表

4、junit的使用

  单元测试

  测试对象是 是一个类中的方法

  juint不是javase的一部分,想要使用导入jar包

    但是,在myeclipse中自带了junit的jar包

  首先junit版本 3.x 4.x

    单元测试方法时候,方法命名规则 public void 方法名() {}

  使用注解方式运行测试方法, 在方法的上面

    @Test:表示方法进行单元测试

public class TestJunit {

    public void testAdd(int a,int b) {

      System.out.println(a+b);

    }

}

    ---  @Test

    public void testAdd1() {

      TestJunit test01 = new TestJunit();

        test01.testAdd(2, 3);

    }

    - 选中方法名称,右键运行 点击run as --- junit  test

    - 当出现绿色条,表示方法测试通过

    - 当出现了红棕色条,表示方法测试不通过

    --- 要运行类中的多个测试方法,点击类中的其他位置,run as --- junit  test

    @Ignore :表示这个方法不进行单元测试

    @Before: 在每个方法执行运行

     @After:在每个方法之后运行

  断言(了解)

  - Assert.assertEquals("测试期望的值", "方法运行的实际的值")

    @Test
public void test02() {
int a = 3;
int b = 5;
int sum = a+b;
//使用断言
//Assert.assertEquals("测试期望的值", "方法运行的实际的值")
Assert.assertEquals(80, sum);
}

  jdk5.0新特性

  jdk 1.1  1.2   1.4   5.0

  泛型、枚举、静态导入、自动拆装箱、增强for、可变参数、反射

5、泛型的简介

  为什么要使用泛型?

  - 一般使用在集合上

  【比如现在把一个字符串类型的值放入到集合里面,这个时候,这个值放入到集合之后,失去本身的类型,只能是object类型,

  这个时候,比如想要对这个值进行类型转换,很容易出现类型转换错误,怎么解决这个问题,可以使用泛型来解决】

  在集合上如何使用泛型

    - 常用集合 list  set  map

    - 泛型语法 集合<String>  比如 List<String>

  在泛型里面写是一个对象,String 不能写基本的数据类型 比如int ()

  写基本的数据类型对应的包装类

    byte -- Byte

    short -- Short

    int -- Integer

     long -- Long

    float -- Float

    double -- Double

    char   -- Character

    boolean -- Boolean

  在list上使用泛型

  list的三种实现 ArrayList  linkedList  Vector

  代码:

    //泛型在list上的使用
@Test
public void testList() {
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//遍历list集合 有几种方式 三种
//普通for循环 迭代器 增强for
//普通for循环
for(int i=0;i<list.size();i++) {
String s = list.get(i);
System.out.println(s);
}
System.out.println("=================");
//使用增强for
for (String s1 : list) {
System.out.println(s1);
}
System.out.println("=================");
//使用迭代器遍历
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}

    作业1: ArrayList  linkedList  Vector 这三个区别

  在set上使用泛型

  代码:

    //泛型使用set集合上
@Test
public void testSet() {
Set<String> set = new HashSet<String>();
set.add("www");
set.add("qqq");
set.add("zzz");
//set.add("qqq"); //无序元素不重复
//遍历set 有几种方式 两种
//迭代器 增强for
//使用增强for遍历
for (String s2 : set) {
System.out.println(s2);
}
System.out.println("=================");
//使用迭代器遍历
Iterator<String> it1 = set.iterator();
while(it1.hasNext()) {
System.out.println(it1.next());
}
}

  在map上面使用泛型

  - map结构:key-valu形式

  代码:

    //在map上使用泛型
@Test
public void testMap() {
Map<String,String> map = new HashMap<String,String>();
map.put("aaa", "111");
map.put("bbb", "222");
map.put("ccc", "333");
//遍历map 有几种遍历方式 两种
// 1、获取所有的key,通过key得到value 使用get方法
// 2、获取key和value的关系
//使用第一种方式遍历
//获取所有的key
Set<String> sets = map.keySet();
//遍历所有key返回的set
for (String key : sets) {
//通过key得到value
String value = map.get(key);
System.out.println(key+" : "+value);
} System.out.println("=============="); //得到key和value的关系
Set<Entry<String, String>> sets1 = map.entrySet();
//遍历sets1
for (Entry<String, String> entry : sets1) {
//entry是key和value关系
String keyv = entry.getKey();
String valuev = entry.getValue();
System.out.println(keyv+" : "+valuev);
}
}

6、泛型使用在方法上

  定义一个数组,实现指定位置上数组元素的交换

 public class TestDemo03 {
public static void main(String[] args) {
//创建一个数组 实现11和13位置交换
  Integer[] arr1 = {10,11,12,13,14};
  System.out.println(Arrays.toString(arr1));
  swap1(arr1,1,3);
  System.out.println(Arrays.toString(arr1));   System.out.println("=========================");
  //创建一个string类型的数组 实现 bb和dd位置交换
  String[] arr2 = {"aa","bb","cc","dd","ff"};
   System.out.println(Arrays.toString(arr2));
   swap1(arr2,1,3);
  System.out.println(Arrays.toString(arr2));
}
private static void swap1(String[] arr2, int i, int j) {
   String temp1 = arr2[i];
  arr2[i] = arr2[j];
   arr2[j] = temp1;
}
private static void swap1(int[] arr1, int i, int j) {
  //定义一个中间变量
  int temp = arr1[i];
  arr1[i] = arr1[j];
  arr1[j] = temp;
}
}

  方法逻辑相同,只是数据类型不同,这个时候使用泛型方法

    /*
使用泛型方法 需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型
写在返回值之前 void之前 <T>
=======表示定义了一个类型 这个类型是 T
在下面就可以使用这个类型了 T
*/ public static <T> void swap1(T[] arr ,int a,int b) {
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

作业2: 实现一个泛型方法,接受任意一个数组,颠倒数组中所有元素

7、泛型在类上的使用(了解)

  在一个类上定义一个类型,这个类型可以在类里面直接使用

public class TestDemo04<T> {
//在类里面可以直接使用T的类型
T aa;
public void test11(T bb) {}
//写一个静态方法 在类上面定义的泛型,不能再静态方法里面使用
public static <A> void test12(A cc) {}
}

8、枚举的简介

  什么是枚举?

    需要在一定的范围内取值,这个值只能是这个范围内中的任意一个。

    现实场景:交通信号灯,有三种颜色,但是每次只能亮三种颜色里面的任意一个

public class TestEnum1 {
//传统的方式
private int color; public void test() {
this.color = 1000;//Color1.RED;
}
}
class Color1 {
public static final int RED = 1;
public static final int GREEN = 2;
public static final int YELLOW = 3;
}
public class TestEnum1 {
//第二种方式
private Color2 color1; public void test() {
this.color1 = Color2.RED;
}
}
class Color2 {
//构造方法私有化
private Color2(String name){}
public static final Color2 RED = new Color2("");
public static final Color2 GREEN = new Color2("");
public static final Color2 YELLOW = new Color2("");
}
public class TestEnum1 {
//第三种方式 jdk5.0新特性 使用枚举
private Color3 color3; public void test() {
this.color3 = Color3.GREEN;
}
}
//使用枚举实现
enum Color3 {
RED,GREEN,YELLOW;
}

使用一个关键字 enum

  enum Color3 {

    RED,GREEN,YELLOW;

  }

  枚举的构造方法也是私有的

  特殊枚举的操作(了解)

  在枚举类里面有构造方法

    构造方法里面有参数,需要在每个实例上面都写参数

public class TestEnum2 {
}
enum Color11 {
RED("red"),GREEN("green"),YELLOW("yellow") ;
private Color11(String name) {}
}

  在枚举类里面有抽象方法

    在枚举的每个实例里面都重写这个抽象方法

 public class TestEnum2 {
}
enum Color11 {
RED("red"){
@Override
public void print1() {
System.out.println("red");
}
},GREEN("green"){
@Override
public void print1() {
System.out.println("green");
}
},YELLOW("yellow") {
@Override
public void print1() {
System.out.println("yellow");
}
};
private Color11(String name) {}
//抽象方法
//当在枚举里面写了抽象方法之后,需要在每个实例上面都实现抽象方法
public abstract void print1();
}

9、枚举的api的操作

  name() :返回枚举的名称

  ordinal() :枚举的下标,下标从0开始

  valueOf(Class<T> enumType, String name) :得到枚举的对象

  还有两个方法,但是这两个方法不在api里面,编译的时候生成两个方法

  valueof(String name)  转换枚举对象

  values()  获得所有枚举对象数组

  练习:枚举对象、枚举对象下标、枚举对象名称表示之间的转换

  - //知道枚举的对象,得到枚举名称和下标

创建枚举类:

enum Color100 {
RED,GREEN,YELLOW;
}
    @Test
public void test1() {
//得到枚举对象
Color100 c100 = Color100.RED;
//枚举名称
String name = c100.name();
//枚举的下标
int idx = c100.ordinal();
System.out.println(name+" "+idx);
}

结果:

RED 0

  - //知道枚举的名称,得到枚举的对象和下标

    @Test
public void test2() {
String name1 = "GREEN";
//得到对象
Color100 c1 = Color100.valueOf(name1);
//枚举下标
int idx1 = c1.ordinal();
System.out.println(idx1);
}

结果:

1

  - //知道枚举的下标,得到枚举的对象和名称

    @Test
public void test3() {
int idx2 = 2;
//得到枚举的对象
Color100[] cs = Color100.values();
//根据下标得到对象
Color100 c12 = cs[idx2];
//得到枚举的名称
String name = c12.name();
System.out.println(name);
}

结果:

YELLOW

10、静态导入(了解)

  可以在代码里面,直接使用静态导入方式,导入静态方法或者常量

    import static XX.XX.xxx

    import static java.lang.System.out;

import static java.util.Arrays.sort;

 package com.li.test05;
/*
演示静态导入
@author yejing
*/
import static java.lang.System.out;
import static java.util.Arrays.sort;
import static java.util.Arrays.toString;
public class TestDemo1 {
public static void main(String[] args) {
out.println("hello"); int[] arr1 = {10,1,3,20,15};
sort(arr1);
//System.out.println(toString(arr1));
}
}

结果:

hello

[1,3,10,15,20]

  比如现在实现一个计算器 ,方法都在Math类里面,不用写Math.

11、自动拆装箱

  装箱

    把基本的数据类型转换成包装类

  拆箱

    把包装类转换成基本的数据类型

  //自动装箱,i是包装类,10是基本数据类型

  Integer i = 10;

  //自动拆箱,m是基本数据类型,i是包装类型

  int m = i;

  在jdk1.4里面如何实现装箱和拆箱

  - //在jdk1.4里面实现拆装箱

  public void test1() {

    //装箱

    Integer m = new Integer(10);

    //拆箱

    int a = m.intValue();

  }

  jdk是会向下兼容

  - 比如 jdk1.4里面写的代码,这个时候到5.0里面也可以运行

  练习:向下兼容

  == 执行的结果是会调用  doSomething(double m)

  == 首先在jdk1.4里面肯定调用这个方法,如果调用下面的方法,需要类型转换,但是jdk1.4不能实现自动拆装箱

  == 由于jdk是向下兼容,所以,在jdk1.4调用这个方法,在jdk5.0里面还是会调用这个方法

public class TestDemo2 {
public static void main(String[] args) {
doSomething(10);
}
public static void doSomething(double m) {
System.out.println("double......");
}
public static void doSomething(Integer a){
System.out.println("integer.....");
}
}

  记住:八种基本的数据类型对应的包装类

    int --- Integer

    char--- Character

12、增强for循环(*****)

  语法 for(遍历出来的值 : 要遍历的集合) {}

  - for(String s : list) {

    System.out.println(s);

  }

  使用场景: 数组;实现Iterable接口的集合 可以使用增强for循环

  在集合上使用增强for循环遍历

    list  set 实现了Iterator接口,所以可以使用增强for循环

    map不能使用增强for循环,没有实现Iterator接口,所以不能使用增强for循环

 public class TestDemo1 {
public static void main(String[] args) {
//创建list
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
//使用增强for循环
for(String s : list) {
System.out.println(s);
}
System.out.println("==============================");
//使用迭代器实现
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}

  增强for循环出现目的:为了替代迭代器

  增强for底层就是迭代器实现的(通过查看.class字节码)

13、内容补充

  (1)泛型擦除

    首先泛型只是出现在源代码阶段,当编译之后泛型不存在

  (2)练习:实现一个泛型方法,接受任意类型的数组,颠倒数组中所有元素

  代码

 //实现一个泛型方法,接受任意类型的数组,颠倒数组中所有元素
public class TestDemo2 {
public static void main(String[] args) {
//int类型
Integer[] arr1 = {10,12,13,14,20};
System.out.println(Arrays.toString(arr1)); //打印原来的 //写方法实现颠倒
reverses(arr1);
System.out.println(Arrays.toString(arr1)); //颠倒后的 System.out.println("===================="); //其他类型
String[] arr2 = {"aa","bb","cc","dd","ff"};
System.out.println(Arrays.toString(arr2));
reverses(arr2);
System.out.println(Arrays.toString(arr2));
} public static <T> void reverses(T[] arr1) {
/*
基本思想:把第一个元素和最后一个元素交换位置,把第二个元素和倒数第二个元素交换位置。。。。
交换 长度/2
*/
//遍历数组
for(int i=0;i<arr1.length/2;i++) {
/*int temp = arr1[0];
arr1[0] = arr1[arr1.length-1];*/
T temp = arr1[i];
arr1[i] = arr1[arr1.length-i-1];
arr1[arr1.length-i-1] = temp;
}
}
/*public static void reverses(Integer[] arr1) {
基本思想:把第一个元素和最后一个元素交换位置,把第二个元素和倒数第二个元素交换位置。。。。
交换 长度/2 //遍历数组
for(int i=0;i<arr1.length/2;i++) {
int temp = arr1[0];
arr1[0] = arr1[arr1.length-1];
int temp = arr1[i];
arr1[i] = arr1[arr1.length-i-1];
arr1[arr1.length-i-1] = temp;
}
}*/
}

14、可变参数

  可变参数可以应用在什么场景:

  实现两个数的相加,实现三个数的相加 四个数的相加

 public class TestDemo1 {
public static void main(String[] args) {
add1(10,20);
add1(10,20,30);
add1(10,20,30,40);
}
//实现两个数的相加
public void add1(int a,int b) {
int sum = a+b;
System.out.println(sum);
}
//实现三个数的相加
public void add1(int a,int b ,int c) {
int sum = a+b+c;
System.out.println(sum);
}
//实现四个数的相加
public void add1(int a,int b ,int c,int d) {
int sum = a+b+c+d;
System.out.println(sum);
}
}

  -- 【如果实现的多个方法,这些方法里面逻辑基本相同,唯一不同的是传递的参数的个数,可以使用可变参数】

  可变参数的定义方法 数据类型...数组的名称

  理解为一个数组,这个数组存储传递过来的参数

  - 代码

 //演示可变参数
public class TestDemo1 {
public static void main(String[] args) {
//int..num;
add1(10,20);
add1(10,20,30);
add1(10,20,30,40);
}
public static void add1(int a, int...nums) {
//nums理解为一个数组,这个数组存储传递过来的参数
//System.out.println(nums.length);
int sum = 0;
//遍历数组
for(int i=0;i<nums.length;i++) {
sum += nums[i];
}
  }
18 }

  注意的地方

    (1)可变参数需要写在方法的参数列表中,不能单独定义

    (2)在方法的参数列表中只能有一个可变参数

    (3)方法的参数列表中的可变参数,必须放在参数最后

      - add1(int a,int...nums)

15、反射的原理(********理解********)

  应用在一些通用性比较高的代码中

  后面学到的框架,大多数都是使用反射来实现的

  在框架开发中,都是基于配置文件开发

  【在配置文件中配置了类,可以通过反射得到类中的所有内容,可以让类中的某个方法来执行】

  类中的所有内容:属性、没有参数的构造方法、有参数的构造方法、普通方法

 public class Person {
//属性
private String name;
private String id;
//没有参数的构造方法
public Person() {}
//有参数的构造
public Person(String name, String id) {
this.name = name;
this.id = id;
}
//普通方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}

  画图分析反射的原理

  首先需要把java文件保存到本地硬盘 .java

  编译java文件,成.class文件

  使用jvm,把class文件通过类加载加载到内存中

  万事万物都是对象,class文件在内存中使用Class类表示

  当使用反射时候,首先需要获取到Class类,得到了这个类之后,就可以得到class文件里面的所有内容

  - 包含属性  构造方法 普通方法

  属性通过一个类 Filed 表示

  构造方法通过一个类 Constructor

  普通方法通过一个类 Method

16、使用反射操作类里面的无参数的构造方法(**会写**)

Person.java

 public class Person {
//属性
private String name;
private String id;
//没有参数的构造方法
public Person() {}
//有参数的构造
public Person(String name, String id) {
this.name = name;
this.id = id;
}
//普通方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}

首先获取到Class类

  // 获取Class类
Class clazz1 = Person.class;
Class clazz2 = new Person().getClass();
Class clazz3 = Class.forName("cn.itcast.test09.Person");

  比如: 要对一个类进行实例化,可以new,不使用new,怎么获取?

  - //得到Class

  Class c3 = Class.forName("cn.itcast.test09.Person");

  //得到Person类的实例

  Person p = (Person) c3.newInstance();

代码

    //操作无参数的构造方法
@Test
public void test1() throws Exception {
//得到Class
Class c3 = Class.forName("cn.itcast.test09.Person");
//得到Person类的实例
Person p = (Person) c3.newInstance();
//设置值
p.setName("zhangsan");
System.out.println(p.getName());
}

17、使用反射操作有参数的构造方法(**会写**)

    //操作有参数的构造方法
@Test
public void test2() throws Exception {
//得到Class
Class c1 = Class.forName("cn.itcast.test09.Person");
//使用有参数的构造方法
//c1.getConstructors();//获取所有的构造方法
//传递是有参数的构造方法里面参数类型,类型使用class形式传递
Constructor cs = c1.getConstructor(String.class,String.class);
//通过有参数的构造方法设置值
//通过有参数的构造方法创建Person实例
Person p1 = (Person) cs.newInstance("lisi","100");
System.out.println(p1.getId()+" "+p1.getName());
}

18、使用反射操作属性(**会写**)

    //操作name属性
@Test
public void test3() {
try {
//得到Class类
Class c2 = Class.forName("cn.itcast.test09.Person");
//得到name属性
//c2.getDeclaredFields();//表示得到所有的属性
//得到Person类的实例
Person p11 = (Person) c2.newInstance();
//通过这个方法得到属性,参数是属性的名称
Field f1 = c2.getDeclaredField("name");
//操作的是私有的属性,不让操作,需要设置可以操作私有属性setAccessible(true),可以操作私有属性
f1.setAccessible(true);
//设置name值 set方法,两个参数:第一个参数类的实例,第二个参数是设置的值
f1.set(p11, "wangwu"); //相当于 在 p.name = "wangwu";
System.out.println(f1.get(p11)); //相当于 p.name
}catch(Exception e) {
e.printStackTrace();
}
}

19、使用泛型操作普通方法(**会写**)

  使用Method类表示普通方法

  代码

    //操作普通方法 ,比如操作 setName
@Test
public void test4() throws Exception {
//得到Class类
Class c4 = Class.forName("cn.itcast.test09.Person");
//得到Person实例
Person p4 = (Person) c4.newInstance();
//得到普通方法
//c4.getDeclaredMethods();//得到所有的普通方法
//传递两个参数:第一个参数,方法名称;第二个参数,方法里面参数的类型
Method m1 = c4.getDeclaredMethod("setName", String.class);
//让setName方法执行 ,执行设置值
//使用invoke(p4, "niuqi");传递两个参数:第一个参数,person实例;第二个参数,设置的值
//执行了invoke方法之后,相当于,执行了setName方法,同时通过这个方法设置了一个值是niuqi
m1.invoke(p4, "niuqi");
System.out.println(p4.getName());
}

  //操作的私有的方法 ,需要设置值是true

  //m1.setAccessible(true);

  当操作的方法是静态的方法时候,因为静态方法调用方式是 类名.方法名,不需要类的实例

  使用反射操作静态方式时候,也是不需要实例

  在invokie方法的第一个参数里面,写一个 null

    - m1.invoke(null, "niuqi");

超全面的JavaWeb笔记day07<Java基础加强>的更多相关文章

  1. 超全面的JavaWeb笔记day03<JS对象&函数>

    1.js的String对象(****) 2.js的Array对象 (****) 3.js的Date对象 (****) 获取当前的月 0-11,想要得到准确的月 +1 获取星期时候,星期日是 0 4.j ...

  2. 超全面的JavaWeb笔记day15<mysql数据库>

    1.数据库的概述 2.SQL 3.DDL 4.DML 5.DCL 6.DQL MySQL 数据库 1 数据库概念(了解) 1.1 什么是数据库 数据库就是用来存储和管理数据的仓库! 数据库存储数据的优 ...

  3. 超全面的JavaWeb笔记day21<过滤器>

    1.过滤器的原理 2.实现过滤器 写一个类实现javax.servlet.Filter接口 在web.xml中对Filter进行配置 3.Filter接口 void init(FilterConfig ...

  4. 超全面的JavaWeb笔记day13<JSTL&自定义标签>

    1.JSTL标签库(重点) core out set remove url if choose when otherwise forEach fmt formatDate formatNumber 2 ...

  5. 超全面的JavaWeb笔记day12<Jsp&JavaBean&El表达式>

    1.JSP三大指令 page include taglib 2.9个内置对象 out page pageContext request response session application exc ...

  6. 超全面的JavaWeb笔记day11<JSP&Session&Cookie&HttpSession>

    1.JSP 2.回话跟踪技术 3.Cookie 4.HttpSession JSP入门 1 JSP概述 1.1 什么是JSP JSP(Java Server Pages)是JavaWeb服务器端的动态 ...

  7. 超全面的JavaWeb笔记day10<Response&Request&路径&编码>

    1.Response 2.Request 3.路径 4.编码 请求响应流程图 response 1.response概述 response是Servlet.service方法的一个参数,类型为java ...

  8. 超全面的JavaWeb笔记day09<Servlet&GenericServlet&HttpServlet&ServletContext>

    1.Servlet概述 2.Servlet接口 3.GenericServlet 4.HttpServlet 5.Servlet细节 6.ServletContext(重要) Servlet概述 生命 ...

  9. 超全面的JavaWeb笔记day22<文件上传>

    文件上传概述 1 文件上传的作用 例如网络硬盘!就是用来上传下载文件的. 在智联招聘上填写一个完整的简历还需要上传照片呢. 2 文件上传对页面的要求 上传文件的要求比较多,需要记一下: 1. 必须使用 ...

随机推荐

  1. 20个可能你不知道Linux网路工具

    如果要在你的系统上监控网络,那么使用命令行工具是非常实用的,并且对于 Linux 用户来说,有着许许多多现成的工具可以使用,如: nethogs, ntopng, nload, iftop, iptr ...

  2. HTML onmousedown 事件属性 关于鼠标按键的问题;

    在项目中遇到一个问题,就是点击任意键关闭弹窗的处理:出现了一个bug:就是在angularjs项目中两个controller之间的事件跳转,使用的ng-show =“iscontext” : 如所示: ...

  3. Celery+python+redis异步执行定时任务

    我之前的一篇文章中写了[Celery+django+redis异步执行任务] 博文:http://blog.csdn.net/apple9005/article/details/54236212 你会 ...

  4. ref和out的使用与区别【转】

    http://www.cnblogs.com/sjrhero/articles/1922902.html out的使用 ———————————————————————————————————————— ...

  5. C# Winform获取bin目录的路径

    //获取到bin目录的下层路径:bin\Debug\ string aa = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBa ...

  6. 【Unity笔记】Awake()和Start()的区别

    Awake在MonoBehavior创建后就立刻调用,Start将在MonoBehavior创建后在该帧Update之前,在该Monobehavior.enabled == true的情况下执行. v ...

  7. 【Unity笔记】UGUI的Image、RawImage控件

    Image控件只能使用Sprite图片,RawImage通常使用Texture类型图片.项目设为2D模式后导入的图片Texture Type会自动转为Sprite. 没有选择源图片时,可以只选择颜色. ...

  8. Hadoop集群时钟同步

    1. 为什么集群需要使用时间同步 暂时保留. 2. hadoop集群如何同步 2.1  以下面hadoop集群为例子: 10.10.11.1 master 10.10.11.2 slave 10.10 ...

  9. Linux下如何查看tomcat是否启动/系统日志等

    Linux下如何查看tomcat是否启动/系统日志等 查看tomcat是否启动 ps -ef | grep tomcat  或者  ps -ef | grep java 启动tomcat(在tomca ...

  10. EasyUI项目中的自定义JS

    自定义方法: (function($) { $.extend($, { //获取下标,删除时使用 getArrayIndex :  function (array,value) { var index ...