更多的内容都在:http://www.wyzc.com/index.php?a=course&m=Index&c=planIndex&treeid=8626&type=2&status=1&tg=7000584774点击打开链接
目录
(一)Java基础语法部分
(1)Java概述
// JDK是Java开发工具包,用于开发Java程序。 // JRE是Java运行时环境,用于运行Java程序,JRE是平台有关的。
// Java是什么? // Java是一个跨平台的编程语言,Java是一个纯软件平台。
// Java有什么? // JavaSEJava标准版,定位在桌面应用程序,同时是其余两个平台的基础。 // JavaMEJava缩微版,定位在移动设备电子产品,例如Android系统的应用和游戏。 // JavaEEJava企业版,定位在大中型企业级的应用。
// Java应用程序的入口 public static void main(String[] arr) {
System.out.println("第一个Java应用程序");
}
|
(2)Java的八种基本数据类型
public static void main(String[] args) {
// Java的八种基本数据类型
// 整数类型的有4种,按照存储范围由小到大依次为:byte、short、int、long // 默认情况下使用int类型
// (1)byte字节类型,占8位 byte b = 1; System.out.println("byte字节类型的值是:" + b);
// (2)short短整型,占16位 short s = 10; System.out.println("short短整型的值是:" + s);
// (3)int整型,占32位 int i = 100; System.out.println("int整型的值是:" + i);
// (4)long长整型,占64位 long g = 1000; System.out.println("long长整型的值是:" + g);
// 浮点数类型有2种,按照存储范围由小到大依次为:float、double // 默认使用double类型
// (5)float单精度浮点数,占32位,实际值比int大 // 注意:float的数值需要添加F或者f指定是float类型 float f = 1.5F; System.out.println("float单精度浮点数的值是:" + f);
// (6)double双精度浮点数,占64位,实际值比long大 // 注意:D表示double类型 double d = 1.23D; System.out.println("double双精度浮点数的值是:" + d);
// (7)char字符类型,单引号,只能存储单个数字、单个字母、单个汉子、占16位 char c = '你'; System.out.println("char字符类型的值是:" + c);
// (8)boolean布尔类型,只有true或者false两个值 boolean boo = true; boo = false; System.out.println("boolean布尔类型的值是:" + boo);
} |
(3)变量与常量
public static void main(String[] args) {
// Java的八种基本数据类型的变量可以理解为是一个容器,可以改变的量。 // 常量使用关键字final定义,表示恒定的量,不能被修改。
int a = 2; int b = 3; // TODO 让两个变量中的值互换
int t = a; a = b; b = t;
System.out.println(a); System.out.println(b);
// 在方法中定义的变量叫做局部变量,局部变量必须要声明而且初始化之后才能使用。
}
|
(4)基本数据类型之间的转换
public static void main(String[] args) {
// (1)同类型的转换,低精度赋值给高精度没问题,高精度赋值给低精度的需要强制类型转换 int i = 10; short s = (short) i; System.out.println(s);
// (2)不同类型的转换,浮点数转换为整数的时候需要注意强制类型转换 double d = 1.34; long g = (long) d; System.out.println(g); double dd = 10L;
// (3)int和char之间的转换 int v = 20320; char c = (char) v; System.out.println(c);
}
|
(5)运算符
(5.1)赋值运算符
// (1)赋值运算符 int a = 2; // a = a + 3; a += 3; System.out.println(a);
short s = 10; // 当数据类型不一致进行计算时,Java会先将低精度的数值往高精度转换,然后再计算。 // s = (short)(s + a); s += a; System.out.println(s);
|
(5.2)算数运算符
// (2)算数运算符 System.out.println(3 + 2); System.out.println(3 - 2); System.out.println(3 * 2); System.out.println(3.0 / 2); System.out.println(3 % 2);
// TODO 练习:打印出下面五位数的的各个位数的值 int value = 12345; System.out.println("个位:" + value % 10); System.out.println("十位:" + value % 100 / 10); System.out.println("百位:" + value / 100 % 10); System.out.println("千位:" + value / 1000 % 10); System.out.println("万位:" + value / 10000);
|
(5.3)比较运算符
// (3)比较运算符,结果一定boolean类型的true或者false System.out.println(2 > 3); System.out.println(2 >= 3); System.out.println(2 < 3); System.out.println(2 <= 3); System.out.println(2 == 3); System.out.println(2 != 3); |
(5.4)逻辑运算符
// (4)逻辑运算符,true和false的运算
// 逻辑非,取反 // System.out.println(!true);
// 逻辑与,两边都为true结果为true,其余情况都为false // System.out.println(true && false); // System.out.println(false && true); // System.out.println(true && true); // System.out.println(false && false);
// 逻辑或,两边有一边为true结果为true,其余情况都为false System.out.println(true || false); System.out.println(false || true); System.out.println(true || true); System.out.println(false || false);
|
(5.5)自增自减运算符
// (5)自增自减运算符 int i = 3; // ++i表示先自增1,然后再参与计算,--i同理 // i++表示先参与计算,然后再自增1,i--同理 System.out.println((3 == i++));
|
(5.6)三目运算符
// (6)三目运算符?: int a = 2; int b = 3; int max = (a > b) ? a : b; System.out.println(max);
// TODO 练习3:使用三目运算符找出3个变量中的最大值
int v1 = 2; int v2 = 3; int v3 = 5;
int m = (v1 > v2) ? v1 : v2; m = (m > v3) ? m : v3; System.out.println(m);
|
(6)流程控制语句
(6.1)if分支语句
// (1)if单分支语句,特点是语句块有可能不执行 if (true) { System.out.println("if单分支语句"); }
// (2)if两个分支语句,至少执行一个分支 if (false) { System.out.println("if两个分支语句true"); } else { System.out.println("if两个分支语句false"); }
// TODO 练习4:求两个变量中的最大值 int a = 2; int b = 5; if (a > b) { System.out.println(a); } else { System.out.println(b); }
// (3)if多个分支语句,最多只能执行一个分支,而且只能执行一个分支 if (true) { System.out.println("1"); } else if (true) { System.out.println("2"); } else { System.out.println("3"); }
// TODO 练习5:三个变量中找最小值 int x = 2; int y = 5; int z = 9;
if (x < y && x < z) { System.out.println(x); } else if (y < x && y < z) { System.out.println(y); } else { System.out.println(z); }
|
(6.2)switch分支语句
// switch分支语句中的类型必须是:byte、short、int、char // break关键字用于跳出switch语句 int i = 85; switch (i / 10) { case 9: { System.out.println("优"); break; } case 8: { System.out.println("良"); break; } case 7: { System.out.println("中"); break; } case 6: { System.out.println("差"); break; } default: { System.out.println("不及格!"); } }
|
(6.3)for循环语句
// for循环 // for (int i = 1; i <= 10; i++) { // System.out.println(i); // }
// TODO 练习1:求1 + 2 + 3 + ... 10的和 // int s = 0; // for (int i = 1; i <= 10; i++) { // s = s + i; // } // System.out.println(s);
// TODO 练习2:求2 * 4 * 6 * 8的乘积 // int m = 1; // for (int i = 2; i <= 8; i += 2) { // m *= i; // } // System.out.println(m);
// TODO 练习3:求2 + 4 + 10 + 14的和 int s = 0; for (int i = 2; i <= 10; i += 2) { if (i == 6 || i == 8 || i == 12) { continue; } s = s + i; }
// 循环中的两个关键字:break关键字和continue关键字。 // break关键字:跳出当前循环、跳出switch语句。 // continue关键字:终止当前这次循环,直接执行下一次循环。
// for (int i = 1; i < 10; i++) { // if (i == 3) { // break; // // continue; // } // System.out.println(i); // }
|
(6.4)while循环语句
int i = 1; while (i < 10) { System.out.println(i); i++; }
|
(6.5)do while循环语句
|
(7)数组
// Java中的类型有两种:一是基本数据类型。二是类类型。
public static void main(String[] args) {
// 一维数组
// (1)创建 // int[] arr1 = { 1, 2, 3 }; // int[] arr2 = new int[10];
// (2)通过下标存取 // int[] arr = new int[3]; // arr[0] = 1; // arr[1] = 2; // int x = arr[0];
// (3)遍历数组 // int[] arr = { 1, 2, 3 }; // for (int i = 0; i < arr.length; i++) { // System.out.println(arr[i]); // }
// 二维数组(用一维数组的方式来理解二维数组)
// (1)创建 // int[][] arr = { { 1, 2 }, { 3, 4 }, { 5 } }; // int[][] arr1 = new int[2][]; // int[][] arr2 = new int[2][3];
// (2)下标存取 // int[][] arr = new int[2][3]; // arr[0][0] = 5; // int val = arr[0][0];
// (3)遍历二维数组 // int[][] arr = { { 1 }, { 4, 5 }, { 1, 2, 3 } }; // for (int i = 0; i < arr.length; i++) { // for (int j = 0; j < arr[i].length; j++) { // System.out.print(arr[i][j]); // } // System.out.println(); // }
// 二维数组练习题:打印杨辉三角
int[][] arr = new int[10][2]; for (int i = 0; i < arr.length; i++) { arr[i] = new int[i + 1]; }
for (int i = 0; i < arr.length; i++) { arr[i][0] = 1; arr[i][i] = 1; }
for (int i = 2; i < arr.length; i++) { for (int j = 1; j < arr[i].length - 1; j++) { arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1]; } }
for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + "\t"); } System.out.println(); }
}
|
(8)函数
// 函数需要掌握: // 调用函数:根据定义调用函数。注意:方法名和參數列表必須完全一致。 // 定义函数:根据需求写出函数定义。
// 现阶段的函数定义格式: // (1)没有返回值的函数方法签名 // public static void 方法名(参数列表) { 方法体 } // (2)有返回值的函数方法签名,return关键字返回到方法的调用处。 // public static 返回类型 方法名(参数列表) { 方法体 return 返回值;}
public static int m1(int a, int b) { int m = (a > b) ? b : a; return m; }
public static int m2(int a, int b, int c) { int m = m1(m1(a, b), c); return m; }
public static void main(String[] arr) {
int max = m2(2, 3, 5); System.out.println(max);
}
|
(二)面向对象的分析和设计OOAD
(2.1)类与对象
/** * * (1)类与对象的关系 * * @author 赵阳 * * 2014-5-30 上午10:29:17 */ public class A {
private String name = "张三";
private int age = 30;
// 类:图纸,模板。 // 类中有类的成员变量和类的成员方法。 // 成员变量:在类中定义的变量叫做成员变量,用来表示类的属性和状态。 // 成员方法:在类总定义的方法叫做成员方法,用来表示类的动作和行为。 // 构造方法:方法名和类同名,没有返回值,也不加void关键字。 // 构造方法的作用:一是创建对象,二是初始化。 // 构造方法注意:如果不写构造方法,系统将提供一个默认的无参的构造方法。
public A() {
}
public A(int a) {
}
// 对象:实例,实体。
public static void run() { System.out.println("跑步"); }
public static void eat() { System.out.println("吃饭"); }
public static void main(String[] args) {
// 创建对象的语法格式: // 类的名字 变量名字 = new关键字 类的构造方法(); A a = new A(4); System.out.println(a.name); System.out.println(a.age); a.eat(); a.run();
}
} |
(2.2)引用与实例
/** * * (2)引用与实例的关系 * * @author 赵阳 * * 2014-5-30 上午11:19:26 */ public class B {
public static void main(String[] args) {
// Java中的类型有2种:八种基本数据类型,类类型(引用类型)。
// 含义:创建一个类的对象,返回对象的内存地址存储到变量中,因此类类型的变量存储的是对象的引用。 // B b = null; // b = new B();// 此对象会被java的垃圾回收机制收回GC // b = new B();
B b1 = new B(); B b2 = b1; B b3 = b1;
// 引用与实例的关系: // 一个引用可以引用零个或一个对象。 // 一个对象可以同时被多个变量引用。
}
}
|
(2.3)值传递
public class C {
public static void m1(int[] arr) { // arr = new int[3]; arr[0] = 4; }
public static void main(String[] args) {
int[] arr = { 1, 2, 3 }; m1(arr); System.out.println(arr[0]);
// Java中的值传递: // 基本数据类型传递的是实实在在的值。 // 类类型传递的是地址的值。
}
}
|
(2.4)成员变量和局部变量
/** * @author 赵阳 * * 2014-6-3 上午9:19:35 * * 成员变量和局部变量 * * 成员变量:在类中定义的变量,作用域在类中都可见。 * 系统会默认赋值。 * 局部变量:在方法或语句块中定义的变量,作用域在方法中都可见。 * 必须初始化才能使用。 * */ public class F {
int age;
{ int c = age; System.out.println(age); }
public static void main(String[] args) {
int a = 2; System.out.println(a);
}
}
|
(2.5)关键字static
// static静态关键字 // 被static修饰的成员属于类,称为类成员静态成员,因此通过“类.成员”的方式来调用。 // 不被static修饰的成员属于对象,称为对象成员非静态成员,因此通过“对象.成员”的方式来调用。 // 静态成员被所有对象共享。 public class A {
static int a = 20;
int b = 30;
static void m1() {
}
void m2() {
}
public static void main(String[] args) {
System.out.println(A.a); A.m1();
A test = new A(); System.out.println(test.b); test.m2();
System.out.println(test.a); test.m1();
}
}
// 类的初始化顺序:加载静态-》加载非静态-》调用构造方法 // 静态不能包含非静态的内容。 public class A {
public void m(int a, int b) {
}
public static void main(String[] args) {
// m(1, 2); // A.m(1, 2);
A a = new A(); a.m(1, 2);
}
}
|
(2.6)关键字final
// final常量关键字 // (1)被final修饰的变量是常量,不能被修改。 //注意:被final修饰的变量必须在声明的同时初始化,因为final变量在编译器加载。 //问题:为何static和final通常连用? // (2)被final修饰的方法不能被覆写。 // (3)被final修饰的类不能被继承。 public class B {
final static int b = 3;
public static void main(String[] args) {
final int a = 2;
}
}
|
(2.7)关键字this和super
// this关键字表示当前类的对象 // this的作用:用于区分成员变量和局部变量。用于构造方法之间的调用,入口一致。 public class Person {
private String name;
private int age;
public Person() { this(""); }
public Person(String name) { this(name, 0); }
public Person(String name, int age) { this.name = name; this.age = age; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public String toString() { return this.name + "\t" + this.age; }
public static void main(String[] args) {
// 重点是OOAP Person p1 = new Person(); p1.setName("张三"); p1.setAge(20); System.out.println(p1);
Person p2 = new Person("李四"); p2.setAge(30); System.out.println(p2);
Person p3 = new Person("王五", 40); System.out.println(p3);
}
}
// super概念:super关键字表示父类的引用 // super作用:调用父类的构造方法,调用父类的被覆写的方法。 // 注意: // 如果一个类不写构造方法,系统将提供一个默认公共的无参构造方法。 // 子类的构造方法第一句会默认调用super() // 好的习惯:最好每个类中都写一个无参的构造方法。 |
(2.8)封装
// Java是一个面向对象的语言,它三个特征 // (1)封装(2)继承(3)多态
// 封装的理解:(1)Java将相关的变量和方法封装到类中。 //(2)Java通过可见性来实现封装。
// 可见性有4个范围3个关键字 // private关键字:当前类可见。 // 默认:当前类可见,本包可见。 // protected关键字:当前类可见,本包可见,外包子类可见。 // public关键字:都可见。
// 修饰class的可见性要么是public,要么是本包可见 public class B {
protected int age = 30;
public static void main(String[] args) {
(new B()).age = 10;
}
}
|
(2.9)String
public static void main(String[] args) {
// 字符串的创建 // String s1 = "你好";// 建议使用字面值 // String s2 = new String("你好");
// 字符串的连接 // String s = "a"; // s += "b"; // s += "c"; // System.out.println(s);
// 连接频繁的时候使用StringBuffer // StringBuffer s = new StringBuffer(); // s.append("a"); // s.append("b"); // s.append("c"); // System.out.println(s);
// 字符串的本质是字符数组 // String s = "123456789"; // for (int i = 0; i < s.length(); i++) { // System.out.println(s.charAt(i)); // }
// 要求至少记住String中的10个方法
String str = "abc"; // str.length()字符串长度 // str.charAt(i)获取字符 // str.toLowerCase()小写 // str.toUpperCase()大写 // str.trim()去除两边空格 // str.substring(1, 2)截取字符串 // str.startsWith("a")以开头 // str.endsWith("c")以结尾 // str.equals("abc")判断值相等 // str.indexOf("bc")获取下标 }
// Java中的类型有两种:8种基本数据类型、类类型
// String字符串类,它的使用频率比8种基本数据类型还要高。非常重要。
// 创建字符串对象方式 // String str1 = "abc";// 强烈推荐采用此种方式创建字符串 // String str2 = new String("abc");
// 第一种方式采用的是"字面值",每次使用Java会先检查内容中是否有此字符串,如果有直接引用。 // 第二种每次都会创建新的对象。
// String a = "abc"; // String b = new String("abc"); // System.out.println(a == b);
// String str1 = "abc"; // String str2 = "abc";
// (1)equals方法:比较两个字符串的值是否相等 // System.out.println(str1.equals(str2));
// (2)substring方法:截取方法 // 字符串的本质是char[],因此下标从0开始 // 一个参数:值 >=i // 两个参数:i <= 值 < j // String s = "abcde"; // System.out.println(s.substring(4)); // System.out.println(s.substring(1, 3));
// (3)toUpperCase方法转换大写 // toLowerCase方法转换小写 // String s = "aBcD"; // System.out.println(s.toUpperCase()); // System.out.println(s.toLowerCase());
// (4)startsWith判断是否以某字符串开头,是返回true,不是返回false // endsWith判断是否以某字符串结尾,是返回true,不是返回false // String s = "abc"; // System.out.println(s.startsWith("a")); // System.out.println(s.endsWith("bc"));
// (5)charAt方法根据下标返回对应的字符 // String s = "abcdef"; // char c = s.charAt(2); // System.out.println(c);
// TODO 打印出给定字符串的各个字符 // length()方法返回的是字符串的长度 // for (int i = 0; i < s.length(); i++) { // System.out.println(s.charAt(i)); // }
// (6)trim方法可以去除字符串两端的空格 // String s = " abc "; // s = s.trim(); // System.out.println(s.length()); // System.out.println(s);
// (7)indexOf方法搜索字符串,找得到则返回起始下标,找不到返回-1 // String s = "abcde"; // int index = s.indexOf("bd"); // System.out.println(index);
|
(2.10)抽象类
// (1)抽象类:被abstract关键字修饰的类叫做抽象类。 public abstract class A {
// (4)构造方法:抽象类中有构造方法。 // 作用:抽象类不能创建对象,所以构造方法的作用就是初始化。 // 初始化谁?子类 public A() {
}
// (2)抽象类中的成员变量和类中的成员变量相同。 protected static final int a = 2;
// (3)抽象类中的成员方法: // 抽象方法:被abstract关键字修饰的并且没有方法体的方法叫做抽象方法。
// 类中方法和抽象类中方法的区别: // 类中的方法的特点是:都是实现的方法!!!!! // 抽象类中的方法的特点是:部分实现!!!!!!!!!!!! public abstract void m1();
public void m2(String a, double d) { }
public static void main(String[] args) { //A a = new A(); }
}
// 抽象类概念:被abstract关键字修饰的class叫做抽象类 public abstract class A {
// 成员变量:abstract class中的成员变量和class中相同。
// 抽象方法:被abstract关键字修饰并且没有方法体的方法叫做抽象方法。 public abstract void m1();
// 实现方法:有方法体的叫做实现方法。 public void m2() { // 空实现 }
// 类和抽象类中方法的区别总结: // 类中的方法必须都是实现的方法。 // 抽象类中的方法可以是抽象方法,也可以是实现方法。 // 包含抽象方法的类一定是抽象类,抽象类中不一定包含抽象方法。
// 抽象类中有构造方法,但是不能创建对象。 public A() {
}
// Java是一个面向对象的语言,而抽象类还不能创建对象,要抽象类干嘛??!! // 抽象类的目的:设计(继承) // 类的目的:实现
}
|
(2.11)继承
// 当定义一个类时,该类会默认继承Object,Java中的单根继承
public static void main(String[] args) {
// (1)创建子类的对象 // Child c = new Child(); // System.out.println(c.getName()); // c.m();
// (2)创建父类的对象 // Father f = new Father(); // System.out.println(f.getName()); // f.m();
// (3)重点:建议使用父类声明变量,来应用子类对象。 // 为什么? // Java思想:面向抽象类做开发的思想。 // Father f2 = new Child2(); // f2.m();
// (4)类和抽象类是可以相互继承的 // 重点:类继承抽象类。
// (5)继承中的初始化顺序 // 父类静态:子类静态->父类非静态->父类构造->子类非静态->子类构造 new C();
// (6)抽象类和继承的关系
}
// 继承:父类有的子类都有。 // 继承原则:满足“是一个”的原则。 // Java中所有的类都是直接或者间接的继承Object类,Java中是单根继承,Object是顶级父类。 // 如果不指定父类,则新定义的类会默认继承Object。
// 继承的讨论:类和抽象类之间可以相互继承,因为都是class类。 // (1)class可以继承class // (2)class可以继承abstract class!!!开发中的最常用!!! // (3)abstract class可以继承class // (4)abstract class可以继承abstract class
|
(2.12)接口
// 接口概念:使用interface关键字定义的叫做接口。 public interface A {
// 接口中的成员变量:接口中的变量默认被public static final修饰。 public static final int age = 20;
// 接口中的成员方法:必须都是抽象方法,默认被public abstract修饰。 public abstract void m();
// 类、抽象类、接口方法区别: // 类中方法:必须都是实现方法。 // 抽象类中方法:可以是实现方法,也可以是抽象方法。只有抽象类可以部分方法实现!!! // 接口中方法:必须都是抽象方法。
// 接口中没有构造方法,不能创建对象。 // 接口目的:设计、更纯粹的设计。
// 类和抽象类之间的关系:继承extends。注意:Java中类的继承每个类只能有一个直接父类。 // 类抽象类和接口之间的关系:实现implements。注意:类可以同时实现多个接口。 // 接口和接口之间的关系:继承extends。注意:Java中接口的继承可以多继承。
}
补充:
// 开发中常见的使用方式一:设计一个类继承一个父类同时实现多个接口。 public class C extends B implements A, E, F {
@Override public void ma() { System.out.println("实现接口中的方法"); }
@Override public void mb() { System.out.println("实现抽象类中的方法"); }
}
补充:
public interface A {
public abstract void m1();
public abstract void m2(); }
public abstract class B implements A {
@Override public void m1() { System.out.println("实现方法一"); }
@Override public abstract void m2();
}
public class C extends B {
@Override public void m2() { System.out.println("实现方法二"); }
}
|
(2.13)多态
//多态: //(1)类内部多态(重载): // 在一个类的内部,如果有多个方法的方法名相同参数列表不同,叫做重载。 // 典型的方法就是构造方法、String.valueOf方法
//(2)继承中多态(覆写): // 在父类和子类中,如果父类和子类的方法的方法签名完全相同,将会调用子类的方法,叫做覆写。 // 典型的方法就是Object中的toString方法
补充1: public static void main(String[] args) {
// 当父类和子类中定义了相同的变量 // (1)直接访问同名变量:此时会调用类型中的变量的值。 // B b1 = new B(); // System.out.println(b1.name); // // A b2 = new B(); // System.out.println(b2.name);
// (2)通过方法访问同名变量:此时会调用方法所在的变量的值。
// B b = new B(); // System.out.println(b.getName());
}
补充2: // 当发生覆写时,子类方法的可见性必须 >= 父类的可见性
|
(三)JDK API
(3.1)集合
/** * * 数组缺点:每次创建都要指定长度。 * * Java中的集合构成:6个接口和一个工具类组成,都在java.util包下。 * * * Collection:集合顶级interface、定义了一个集合所具备的通用抽象方法。 * List:标准是有序。ArrayList实现类。 * Set:标准是不重复。HashSet实现类。 * SortedSet:标准是不重复,排序。TreeSet实现类。 * * Map * SortedMap * * Collections集合工具类可以对集合排序 * java.lang.Comparable * * @author 赵阳 * * 2014-6-13 上午9:28:17 */ public class A {
public static void main(String[] args) {
// List接口
// 创建了一个ArrayList集合对象 // 泛型:可以指定集合中存储的类型,在编译器检查,强烈建议使用泛型。 List<String> list = new ArrayList<String>();
// 添加元素 list.add("a"); list.add("b"); list.add("c");
// 删除元素 // list.remove("b"); // list.remove("c");
// 更新元素 //list.set(1, "你好");
// ArrayList低层是通过数组实现的,因此获取是通过下标获取的。 // System.out.println(list); // String s1 = (String)list.get(0); // System.out.println(s1);
// 遍历List集合
// 第一种遍历方法通过下标遍历 for (int i=0; i < list.size(); i++) { System.out.println(list.get(i)); }
// 第二种遍历方法简单遍历 for (String s:list) { System.out.println(s); }
// 第三种遍历方法:迭代器遍历,所有集合通用的遍历方法,建议采用此种遍历。 // 将List集合返回到一个迭代器中(设计模式之一:迭代器设计模式) Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String s = iterator.next(); System.out.println(s); }
}
}
public static void main(String[] args) {
// Set接口
// 创建一个Set集合 Set<String> set = new HashSet<String>();
// 添加 set.add("a"); set.add("b"); set.add("c");
// 删除 set.remove("a");
System.out.println(set);
// 遍历Set集合方法 Iterator<String> iterator = set.iterator(); while (iterator.hasNext()) { String s = iterator.next(); System.out.println(s); }
}
public static void main(String[] args) {
// SortedSet接口
SortedSet<String> set = new TreeSet<String>();
set.add("d"); set.add("b"); set.add("a"); set.add("a"); set.add("a"); set.add("c");
System.out.println(set);
Iterator<String> iterator = set.iterator(); while (iterator.hasNext()) { String s = iterator.next(); System.out.println(s); }
}
public static void main(String[] args) {
// Map接口
// Map<String, String> map = new HashMap<String, String>(); SortedMap<String, String> map = new TreeMap<String, String>();
// 添加一组键值对(key-value) map.put("2", "张三"); map.put("1", "李四"); map.put("3", "王五");
// 根据key获取value String name = (String) map.get("1"); System.out.println(name);
// 获取key的集合 // Set<String> set = map.keySet(); // System.out.println(set);
// 遍历map集合方法一 // for (String key : set) { // System.out.println(key + "\t" + map.get(key)); // }
// 遍历map集合方法二 Set<Entry<String, String>> set = map.entrySet(); for (Entry<String, String> entry : set) { String key = entry.getKey(); String value = entry.getValue(); System.out.println(key + "\t" + value); }
}
public static void main(String[] args) {
// 数组和集合的区别: // 数组是静态的必须是定长,集合是动态的。 // 数组中既可以存储基本数据类型,也可以存储类类型。 // 集合只能存储类类型。
// Java的八种基本数据类型都有对应的类类型 // byte->Byte // short->Short // int->Integer // long->Long // float->Float // double->Double // boolean->Boolean // char->Character
List<Integer> list = new ArrayList<Integer>(); // 自动装箱过程 int a = 100; list.add(a); list.add(200); list.add(3); System.out.println(list); // 自动拆箱过程 for (int value : list) { System.out.println(value); }
}
集合排序 public int compareTo(Object o) { Member member = (Member) o; // return (int) (this.salary - member.salary); return this.name.compareTo(member.name); }
|
(3.2)异常
// 异常: // (1)异常的5个关键字 // 捕获(程序本身的问题就捕获):try(包含异常代码)、catch(捕获异常从小到大)、finally(最终执行) // 抛出(调用者问题就抛出):throw(在方法内部抛出)、throws(方法声明处抛出)
// (2)异常体系结构 // Throwable类-Error错误类(非检查型) // (异常顶级父类) -Exception异常类(检查型) -RuntimeException运行时异常类(非检查型)
// Java中的异常分两种:检查型异常(必须处理)、非检查型异常(非必须处理)
// (3)自定义异常 // 自定义异常必须继承Exception异常类
public class A {
public static void main(String[] args) {
// 认识一下常见的异常有哪些: // (1)算数异常ArithmeticException try { System.out.println("111"); // 发生异常时,程序会立刻终止,然后抛出异常 String s = null; System.out.println(s.equals("")); System.out.println("222"); } catch (ArithmeticException e1) { System.out.println("算数异常"); } catch (ArrayIndexOutOfBoundsException e2) { System.out.println("下标越界异常"); } catch (RuntimeException e3) { System.out.println("空指针异常"); } finally { System.out.println("fainll语句块中的代码一定会被执行!!!"); }
// (2)数组小标越界异常ArrayIndexOutOfBoundsException // int[] arr = { 1, 2, 3 }; // System.out.println(arr[3]);
// (3)空指针异常NullPointerException // String str = null; // System.out.println(str.equals("abc"));
} }
// 自定义异常类的写法 public class MyException extends Exception {
public MyException(String str) { super(str); }
}
|
(3.3)封装类
public static void main(String[] args) {
// 8种基本数据类型都有对应的封装类 // Byte、Short、Integer、Long // Float、Double // Boolean、Character
// 作用:(1)用于集合存储。(2)将String转换为基本数据类型。
// List<Integer> list = new ArrayList<Integer>(); // list.add(100); // int value = list.get(0);
// 基本数据类型和字符串之间的相互转换: // 基本数据类型->String通过重载方法valueOf即可 // String->基本数据类型通过基本类型对应的封装类即可
// byte b = 10; // String s = String.valueOf(b); // b = Byte.parseByte(s);
// int b = 100; // String s = String.valueOf(b); // b = Integer.parseInt(s); // // double d = 1.35; // String ss = String.valueOf(d); // d = Double.parseDouble(ss);
// 注意:java.lang.NumberFormatException数字格式化异常 // int i = Integer.parseInt("你abc");
// char[]之间String相互转换 char[] arr = { 'a', 'b', 'c' }; String str = String.valueOf(arr); arr = str.toCharArray();
}
|
(3.4)日期
/** * 必须养成查看Java API文档的习惯,从现在起,每讲一个新的API都要先看下API文档。 * * */ public static void main(String[] args) {
// 创建一个当前日期时间的对象 // Date date = new Date(); // System.out.println(date);
// Date类型和String类型之间的相互转换都要通过SimpleDateFormat类 // 创建对象需要指定一个日期格式 // // Date->String // SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // String str = sdf.format(date); // System.out.println(str);
// String->Date // String str = "06-16:2014年"; // SimpleDateFormat sdf = new SimpleDateFormat("MM-dd:yyyy年"); // Date date = null; // try { // date = sdf.parse(str); // System.out.println(date); // } catch (ParseException e) { // // ParseException解析异常 // e.printStackTrace(); // } // System.out.println(date);
// Date类不是按照年月日时分秒来存储的,存储的是距离历史一个时间点的毫秒数。 // 在实际开发中Date用于日期的计算 // Date date = new Date(); // 返回毫秒数 // long time = date.getTime(); // System.out.println(time);
// 练习题一:求100天之后是几月几号
Date date = new Date(); date.setTime(date.getTime() + 100 * 24 * 60 * 60 * 1000L); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); System.out.println(sdf.format(date));
// 练习题二:求距离2016年10月1日相差多少天
}
|
(3.5)I/O
// Java的I/O体系:装饰设计模式 // 字节输入流java.io.InputStream // 字节输出流java.io.OutputStream // 字符输入流java.io.Reader // 字符输出流java.io.Writer
public static void main(String[] args) {
// Java的I/O
FileReader fr = null; BufferedReader in = null; try {
// 创建一个文件输入流对象 fr = new FileReader("f:\\test.txt"); // 创建 in = new BufferedReader(fr); String str = ""; while ((str = in.readLine()) != null) { System.out.println(str); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { // 进行Java的IO操作时要注意: // 有打开一定有关闭,关闭顺序和打开顺序相反。 try { in.close(); fr.close(); } catch (IOException e) { e.printStackTrace(); }
}
}
public static void main(String[] args) {
FileWriter fw = null; BufferedWriter bw = null; try { fw = new FileWriter("f:\\abc.txt", true); bw = new BufferedWriter(fw); for (int i = 0; i < 10; i++) { bw.write("顺口溜豆腐加两块豆腐"); bw.write("\r\n"); } } catch (IOException e) { e.printStackTrace(); } finally { try { bw.close(); fw.close(); } catch (IOException e) { e.printStackTrace(); } }
}
|
(3.6)设计模式
/** * * 设计模式之:单例模式一 * * 要求设计一个类A,对外只提供一个对象。 * */ public class A {
private static A a = new A();
private A() {
}
public static A m() { return a; }
}
/** * * 单例模式二 */ public class B {
private static B b;
private B() {
}
public static B m() { if (b == null) { b = new B(); } return b; }
}
public class Client {
public static void main(String[] args) {
// 使用者,调用端,客户端
// (1)类声明变量 Audi car1 = new Audi(); car1.driver();
// (2)接口声明变量 Car car2 = new Audi(); car2.driver();
// (3)工厂模式 Car car3 = CarFactory.getCar("1"); car3.driver();
// (4)Spring IOC
}
}
// 汽车工厂类 public class CarFactory {
public static Car getCar(String name) {
if (name.equals("1")) { return new Audi(); } else if (name.equals("2")) { return new Benz(); }
return null; }
}
|
(3.7)eclipse调试
F5:跟踪到方法内部 F6:跟踪当前代码 F8:跟踪到下一个断点,或者执行完
|
(3.8)内部类和匿名类
// 一个文件中可以定义多个类,但是注意文件名必须和public修饰的类名相同。
// 嵌套类概念:可以在一个类中定义另外一个类。 // (1)静态嵌套类(开发中用的非常少) // (2)非静态嵌套类(内部类):成员内部类、局部内部类、匿名类。
public class A {
static class B {
}
class C {
}
public void m() {
class D {
}
}
}
public static void main(String[] args) {
// 创建静态嵌套类的对象 // A.B b = new A.B(); // System.out.println(b);
// 创建内部类的对象 A a = new A(); A.C c = a.new C(); System.out.println(c);
}
public static void main(String[] args) {
// 匿名类的使用 // 实现接口 + 创建对象 E e = new E() {
public void m() { System.out.println("方法的实现!"); }
}; e.m();
} |
(3.9)dom4j解析XML
dom4j是java语言的文档对象模型的实现,用来解析XML文件。 XML文件的概念: (1) XML文件的首行必须声明部分,而且不能有空格。 (2) XML文件只能有一个根节点。 (3) XML文件只有三类节点:元素节点、属性节点、文本节点。 (4) 元素节点有打开,必须有关闭。 (5) 属性节点的值必须使用双引号。 |
public static void main(String[] args) {
// 编码的理解
String str = "你好"; try { // 参数指定按照什么编码返回字节数组 // UTF-8编码:一个汉字3个字节,国际化通用 // GBK编码:一个汉字2个字节,中文编码 byte[] arr = str.getBytes("GBK"); for (byte b : arr) { System.out.println(b); } } catch (UnsupportedEncodingException e) { e.printStackTrace(); }
} |
public static void main(String[] args) {
// 第一部分:获取一个Document(文档对象模型)对象的方法:
// (1)从一个文件获取一个document对象 try { // (1)创建一个文件对象 // 绝对路径: // File file = new File("f:\\members.xml"); // 相对路径:相对于工程的路径!!! File file = new File("members.xml"); // (2)创建一个解析器对象 SAXReader reader = new SAXReader(); // (3)将xml文件转化为document对象 Document document = reader.read(file); System.out.println(document); } catch (DocumentException e) { e.printStackTrace(); }
// (2)通过一个xml片段转化为一个document对象 // try { // String xmlstr = "<members></members>"; // Document document = DocumentHelper.parseText(xmlstr); // System.out.println(document); // } catch (DocumentException e) { // e.printStackTrace(); // }
// (3)创建一个空的document对象 // Document document = DocumentHelper.createDocument(); // System.out.println(document);
}
public static void main(String[] args) {
// Document对应XML文件 // Element对应元素节点 // Attribute对应属性节点
// 第二部分:怎样获取元素节点、属性节点、文本节点。
try { File file = new File("company\\members.xml"); SAXReader reader = new SAXReader(); Document document = reader.read(file);
// (1)获取根节点 Element root = document.getRootElement();
// (2)获取多个元素节点的集合 List<Element> list = root.elements("member"); for (Element e : list) { // (3)获取属性节点 Attribute att = e.attribute("name"); System.out.println("名字:" + att.getText()); // (4)获取单个元素节点的对象 Element ele = e.element("age"); System.out.println("年龄:" + ele.getText()); }
} catch (DocumentException e) { e.printStackTrace(); }
}
public static void main(String[] args) {
try {
// (1)读:将xml文件转化为内存中的document对象 File file = new File("company/members.xml"); SAXReader reader = new SAXReader(); Document document = reader.read(file);
// TODO: 从document中将张三的元素节点删除
// TODO: 从document中将李四的年龄改为50
// TODO: 从document中将王五的名字改为赵六
// (2)写:将内存中的document对象转换到xml文件中 OutputFormat of = OutputFormat.createPrettyPrint(); of.setEncoding("GBK");// 设置编码方式 XMLWriter w = new XMLWriter(new FileWriter("company/out.xml"), of); w.write(document); w.close(); } catch (DocumentException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }
}
|
(3.10)log4j在App中的使用
// log4j是用Java程序的日志记录技术 public class A {
private final static Logger logger = Logger.getLogger(A.class);
public static void main(String[] args) {
// log4j的5个日志等级: // debug > info > warn > error > fatal
logger.debug("debug!"); logger.info("info!"); logger.warn("warn!"); logger.error("error!"); logger.fatal("fatal!");
}
}
log4j.rootLogger=warn, stdout, R
log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# Pattern to output the caller's file name and line number. log4j.appender.stdout.layout.ConversionPattern=%d %5p [%t] (%F:%L) - %m%n
log4j.appender.R=org.apache.log4j.RollingFileAppender log4j.appender.R.File=zhaoyang.log
log4j.appender.R.MaxFileSize=1000KB # Keep one backup file log4j.appender.R.MaxBackupIndex=1
log4j.appender.R.layout=org.apache.log4j.PatternLayout log4j.appender.R.layout.ConversionPattern=%d %5p [%t] (%F:%L) - %m%n
|
(3.10)线程
// 并发:单处理器,某一个时刻只有一个线程执行。 // 并行:多处理器,某一个时刻可以有多个线程执行。 // (多核时代:充分利用CPU、省时、响应快、用户体验好。)
// 多线程的实现方法有两种: // (1)继承Thread类来实现多线程。 // (2)实现Runnable接口实现多线程。
public static void main(String[] args) {
// 我们之前写的程序都是单线程的程序 while (true) { // 打印出当前线程的名字 System.out.println(Thread.currentThread().getName()); }
}
// 通过继承Thread类实现多线程 public class B extends Thread {
// run方法是多线程的业务方法 public void run() { while (true) { System.out.println(Thread.currentThread().getName()); } }
public static void main(String[] args) {
// 调用方法: B b1 = new B(); b1.start();// 启动一个线程
B b2 = new B(); b2.start();// 启动一个线程
}
}
// 通过实现Runnable接口实现多线程 public class C implements Runnable {
// 多线程的业务方法 public void run() { while (true) { System.out.println(Thread.currentThread().getName()); } }
public static void main(String[] args) {
// 调用方法: C c1 = new C(); Thread t1 = new Thread(c1); t1.start();
C c2 = new C(); Thread t2 = new Thread(c2); t2.start();
}
}
// 银行类 public class Bank {
private int count;
public Bank(int count) { this.count = count; }
public void getMoney(int money) {
Date date = new Date();
synchronized (date) {
if (money < count) {
try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); }
count -= money; System.out.println("余额为:" + count); } else { System.out.println("余额不足!!!"); }
if (count < 0) { System.out.println("银行存款出现负数:" + count); System.exit(1); } }
}
}
// 线程死锁的场合以及怎样解决 // (1)建议run方法中不要使用同步方法或者同步块。 // (2)多个方法中同步块的锁定顺序应该一致。 public class A extends Thread {
private static final String str = "你好";
public void run() { synchronized (this) { while (true) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()); } } }
public static void main(String[] args) {
A a1 = new A(); a1.start();
A a2 = new A(); a2.start();
}
}
public class B implements Runnable {
private static final String s1 = "abc"; private static final String s2 = "123";
public void run() { while (true) { m1(); m2(); } }
public void m1() { synchronized (s1) { synchronized (s2) { System.out.println("执行方法一!!!"); } } }
public void m2() { synchronized (s1) { synchronized (s2) { System.out.println("执行方法二!!!"); } } }
public static void main(String[] args) { (new Thread(new B())).start(); (new Thread(new B())).start(); }
}
|
(3.11)反射
import java.lang.Class; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Constructor;
// 反射:一种“看透”Java的能力,JDK中的反射API都在java.lang.reflect.* // Java中反射机制的核心API(Java思想一切皆对象) // (1)Class表示类 // (2)Field表示成员变量 // (3)Method表示成员方法 // (4)Constructor表示构造方法 public class Member {
private String name;
private int age;
public Member() { this("匿名", 0); }
public Member(String name, int age) { this.name = name; this.age = age; }
public void m() { System.out.println("方法一"); }
public String toString() { return this.name + "\t" + this.age; }
public static void main(String[] args) {
// 创建对象 // Member m1 = new Member(); // System.out.println(m1);
// 用Java的反射机制创建对象 // try { // // 加载类,获取一个Class类型的对象 // Class c = Class.forName("com.a.Member"); // // 调用类中无参的构造方法创建对象 // Member m2 = (Member) (c.newInstance()); // System.out.println(m2); // } catch (ClassNotFoundException e) { // e.printStackTrace(); // } catch (InstantiationException e) { // e.printStackTrace(); // } catch (IllegalAccessException e) { // e.printStackTrace(); // }
// 思考:实现此方法 Object obj = getMember("member"); Member m3 = (Member) obj; System.out.println(m3);
}
// Spring框架IOC实现原理: // 读取xml文件,传入id属性的值,返回class属性对应的类的对象 private static Object getMember(String id) { return null; } } |
(3.12)Spring IoC
Spring是一个轻量级的JavaEE框架。 Struts是一个web框架。 Hibernate是一个持久层框架。 MyBatis是一个持久层框架。
IoC:控制反转(思想)。是整个Spring框架的灵魂核心。 有了Spring的IoC之后,IoC容器控制应用程序所需要的外部资源,然后反转给应用程序。
DI:依赖注入(思想)。 |
(3.13)正则表达式
import java.util.regex.*;
// matches函数:如果匹配则返回true,否则返回false // 第一个参数:正则表达式 // 第二个参数:要匹配的字符串
// (1)+表示出现一次或多次、*零或多次、?零或1次 boolean boo = Pattern.matches("m(o?)n", "moon");
// (2)[]匹配其中的一个字符、()匹配其中的多个字符 boolean boo = Pattern.matches("m[abc]n", "man"); boolean boo = Pattern.matches("m(aa|bb|cc)n", "mbbn");
// (3)\d表示数字、\w表示字符 boolean boo = Pattern.matches("\\d+", "123"); boolean boo = Pattern.matches("[0-9]+", "12345"); boolean boo = Pattern.matches("\\w+", "abcXYZ0123"); System.out.println(boo);
// (4)匹配开头^、匹配结尾$ boolean boo = Pattern.matches("^m[abc]n$", "man"); System.out.println(boo);
// (5)精确数量 boolean boo = Pattern.matches("^m(o{2,5})n$", "mooooon"); System.out.println(boo);
常用的正则验证函数: function isInteger(str){ return str.search("^[1-9]+(\\d*)$")==0; }
/** * Positive Integer Check */ function isPositiveInteger(str){ var regex=new RegExp("^[1-9]+\\d*$"); return regex.test(str); }
/** * Negative Integer Check */ function isNegativeInteger(str){ var regex=new RegExp("^-{1}\\d+$"); return regex.test(str); }
/** * Nonnegative Integer Check */ function isNonnegativeInteger(str){ var regex=new RegExp("^\\d+$"); return regex.test(str); }
/** * Integer Check */ function isInteger(str){ var regex=new RegExp("^-?\\d+$"); return regex.test(str); }
/** * Rational number Check */ function isRationalNumber(str){ var regex=new RegExp("^-?\\d+(\\.*)(\\d*)$"); return regex.test(str); }
/** * Letter Check */ function isLetter(str){ var regex=new RegExp("^[a-zA-Z]+$"); return regex.test(str); }
/** * Letter Integer Check */ function isLetterOrInteger(str){ var regex=new RegExp("^[a-zA-Z0-9]+$"); return regex.test(str); }
/** * Email Check */ function isEmail(str){ var regex=new RegExp("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$"); return regex.test(str); }
/** * Character Check */ function isCharacter(str){ var regex=new RegExp("^[\u4E00-\u9FA5]+$"); return regex.test(str); }
/** * Currency Check */ function isCurrency(str){ return str.search("^\\d+(\\.\\d{0,2})*$")==0; }
function isABC(str){ alert(str); //var regex=/\d+/; var regex=new RegExp("^[abc]$"); var b=regex.test(str); alert(b); return regex.test(str); }
|