JAVA程序设计 - 图文

JAVA

1．Java中的关键字：

public class HelloWorld {

public static void main(String[] args){ System.out.println(\ } }

2．Java标识符（变量）：

1. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴

2. 标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以

3. 标识符是严格区分大小写的。 所以涅，一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！ 4. 标识符的命名最好能反映出其作用，做到见名知意。

3．Java中的数据类型： 分 类 数据类型 关键字 byte 字节型

short 短整型 整数类 int 整型 long 长整型 char 文本类 字符型 float 浮点型 浮点类 double 双精度型 boolean 逻辑类 逻辑型 4．Java中变量的使用规则：

占字节数 8 16 32 64 16 32 64 8 缺省数值 0 0 0 0 ′\%u 0000′ 0.0F 0.0D False 取 值 范 围 -2 ～2-1 -2 15～2 15-1 -2 31～2 31-1 -2 63～2 63-1 ′\%u 0000′ ～ ′\%u FFFF′ — — True、False 7 7 1、Java 中的变量需要先声明后使用

2、变量使用时，可以声明变量的同时进行初始化，也可以先声明后赋值 3、变量中每次只能赋一个值，但可以修改多次

4、main 方法中定义的变量必须先赋值，然后才能输出

5、虽然语法中没有提示错误，但在实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如后期跨平台操作时出现乱码等等

5．Java中的类型转换

Java中的自动类型转换： Java中的强制类型转换： String str = \

int a = Integer.parseInt(str);

使用Integer类的方法parseInt将String转换为对应的整数。

6．Java常量的应用：

所谓常量，我们可以理解为是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变。 语法：final 常量名 = 值; 常量名一般使用大写字符。

7．Java中的注释：

Java 中注释有三种类型：单行注释、多行注释、文档注释

8．Java中运算符：

算术运算符 + - * / % ++ -- 赋值运算符 = += -= *= /= %= 运算符 含 义 示 例 等价表达式 += a += b a = a + b 加并赋值运算符

减并赋值运算符 a－= b -= a = a-b

*= a *= b a = a * b 乘并赋值运算符 /= a /= b a = a / b 除并赋值运算符 %= a %= b a = a % b 取模并赋值运算符 &= a &= b a = a & b 与并赋值运算符

|= a |= b a = a | b 或并赋值运算符

^= a ^= b a = a ^ b 或并赋值运算符 <<= a <<= b a = a << b 左移并赋值运算符 >>= a >>= b a = a >> b 右移并赋值运算符

>>>= a >>>= b a = a >>> b 右移并赋值运算符 比较运算符 > < >= <= == !=

布尔逻辑运算符 && || ! ^(异或：如果仅有一个为true，则返回true)

运算符 含 义 示 例 规 则

! 取反 ! a a为真时，结果为假；a为假时，结果为真

& 非简洁与 a & b a、b都为真时，结果为真；a、b有一个为假时，结果为假

| 非简洁或 a | b a、b有一个为真时，结果为真；a、b都为假时，结果为假

^ 异或 a ^ b a、b不同真假时结果为真；a、b同真或同假时，结果为假

&& 简洁与 a && b a、b都为真时，结果为真；a、b有一个为假时，结果为假

|| 简洁或 a || b a、b有一个为真时，结果为真；a、b都为假时，结果为假 条件运算符 条件运算符（ ? : ）也称为 “三元运算符”。

二进制位运算：>>, <<, >>>, &, |, ^, ~ 除~以外，其余均为二元运算符，操作数只能为整型和字符型数据 有点：特定情况下，计算方便，速度快，被支持面广，如果用算数方法，速度慢，逻辑复杂。

1） 按位与 & （两位全为1，结果才为1） 2） 位求反 ~ 3） 按位或 | 4） 按位异或 ^ 5） 左移 << 6） 右移 >>

7） 不带符号右移 >>>

右移运算符对应的表达式为x>>a，运算的结果是操作数x被2的a次方来除，左移运算符对应的表达式为x<>b 36/22

a<

9．Java中运算符的优先级： 含义描述 优先级 1 分隔符

2 单目运算、字符串运算 3 算术乘除运算 4 算术加减运算 5 移位运算 6 大小关系运算、类运算

7 8 9 10 11 12 相等关系运算 按位与，非简洁与 按位异或运算 按位或，非简洁或 简洁与 简洁或 运 算 符 [] () ; , ++ -- + - ～ ! (类型转换符) * / % + - << >> >>> < > <= >= instanceof = = ! = & ^ | && || 结合性 *右到左 左到右 左到右 左到右 左到右 左到右 左到右 左到右 左到右 左到右 左到右

10．Java中常用的语句

Java条件语句之 if：

Java条件语句之 if...else： Java条件语句之多重 if： Java条件语句之嵌套 if： Java条件语句之 switch： Java循环语句之 while： Java循环语句之 do...while: Java循环语句之 for:

Java循环跳转语句之 break: Java循环跳转语句之 continue:

11．Java中的数组:

int[] scores = { 78, 93, 97, 84, 63 }; int scores []= { 78, 93, 97, 84, 63 };

数组名.length 用于获取数组的长度。

//声明数组 int a[];

//创建数组 a = new int[3];

Int arr[] = new int[10]{10,24,24,22,64}

A）使用 Arrays 类操作 Java 中的数组：

使用Arrays类时必须先导入包：import java.util.Arrays;

Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。

该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等 1、 排序 语法： Arrays.sort(数组名);

可以使用 sort( ) 方法实现对数组的排序， 只要将数组名放在 sort( ) 方法的括号中， 就可以完成对该数组的排序（按升序排列） 2、 将数组转换为字符串

语法： Arrays.toString(数组名); 可以使用 toString( ) 方法将一个数组转换成字符串， 该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开， B）使用 foreach 操作数组: 语法： for (元素类型 元素变量 : 变量对象){ 执行的代码

}

foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，

在遍历数组、集合时， foreach 更简单便捷。

从英文字面意思理解 foreach 也就是“ for 每一个”的意思。

11．Java 中的二维数组：

12．如何定义 Java 中的方法：

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。 一般情况下，定义一个方法的语法是：

饰访问修符 返回值类型 方法名(参数列表){

方法体 }

Java中调用方法： 对象名.方法名();

1、 访问修饰符：方法允许被访问的权限范围， 可以是 public、protected、private 甚至可以省略 ，其中 public 表示该方法可以被其他任何代码调用

2、 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值 3、 方法名：定义的方法的名字，必须使用合法的标识符

4、 参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开

5、 根据方法是否带参、是否带返回值，可将方法分为四类： 无参无返回值方法 无参带返回值方法 带参无返回值方法 带参带返回值方法 实例1：无参无返回值方法 //定义一个类

public class HelloWorld {

//定义了一个方法名为 print 的方法，实现输出信息功能 public void print() { System.out.println(\}

public static void main(String[] args){

//在 main 方法中调用 print 方法 HelloWorld test=new HelloWorld(); test.print(); } }

实例2：无参无返回值方法的使用： public class HelloWorld { public static void main(String[] args) {

// 创建对象，对象名为hello HelloWorld hello = new HelloWorld();

// 调用方法,通过对象名.方法名()的形式调用方法 hello.showMyLove(); }

/*

* 定义无参无返回值的方法 */

public void showMyLove() {

System.out.println(\我爱慕课网!\ }

实例3：无参带返回值方法的使用： 不容忽视的“小陷阱”：

1、 如果方法的返回类型为 void ，则方法中不能使用 return 返回值！ 2、 方法的返回值最多只能有一个，不能返回多个值

3、 方法返回值的类型必须兼容，例如，如果返回值类型为 int ，则不能返回 String 型值 public class HelloWorld { public static void main(String[] args) { // 创建名为hello的对象 HelloWorld hello = new HelloWorld(); // 调用hello对象的calcAvg()方法，并将返回值保存在变量avg中Java 中无参带返回值方法的使用 double avg = hello.calcAvg(); System.out.println(\平均成绩为：\ } // 定义一个返回值为double类型的方法 public double calcAvg() { double java = 92.5; double php = 83.0; double avg = (java + php) / 2; // 计算平均值 // 使用return返回值 return avg; } }

实例4：Java 中带参无返回值方法的使用： public class HelloWorld { public static void main(String[] args) { // 创建对象，对象名为hello HelloWorld hello = new HelloWorld(); // 调用方法，传入两门课程的成绩 hello.calcAvg(94, 81); } /* * 功能：计算两门课程考试成绩的平均分并输出平均分 * 定义一个包含两个参数的方法，用来传入两门课程的成绩 */ }

public void calcAvg(int java,int html){ double avg = (java + html)/2.0;//计算平均分 System.out.println(\平均分:\输出平均分 }

一定不可忽视的问题：

1、 调用带参方法时，必须保证实参的数量、类型、顺序与形参一一对应 2、 调用方法时，实参不需要指定数据类型，如

3、 方法的参数可以是基本数据类型，如 int、double 等，也可以是引用数据类型，如 String、数组等 4、 当方法参数有多个时，多个参数间以逗号分隔 实例5：带参带返回值方法的使用： import java.util.Arrays; public class HelloWorld { public static void main(String[] args) { HelloWorld hello = new HelloWorld(); int[] scores={79,52,98,81}; //调用方法，传入成绩数组，并获取成绩的个数 int count=hello.sort(scores); System.out.println(\共有\个成绩信息！\ } /* * 功能：将考试成绩排序并输出，返回成绩的个数 * 定义一个包含整型数组参数的方法，传入成绩数组 * 使用Arrays类对成绩数组进行排序并输出 * 方法执行后返回数组中元素的个数 */ public int sort(int[] scores){ Arrays.sort(scores); System.out.println(Arrays.toString(scores)); }

//返回数组中元素的个数 return scores.length; }

12.1 访问修饰符 类 同一个包 子类 private Y N N Y Y N 默认 protected Y Y Y public Y Y Y 示例: a.java //文件名 package nf; //包名 class A{ private int n1; //定义private int n2; //定义 默认 protected int n3; //定义 protected public int n4; //定义public void fun(){

n1 = n2 = n3 = n4 = 10; //这里可以访问n1,n2,n3,n4,因为在同一个类里,四个修饰符都能访问

不同包非子类 N N N Y

}

Static fun2(){ //也可以使用以下方法访问

A a = new A(); //定义一个引用的对象 a.n2 = a.n4 = a.n3 = 10; //这样也是可行的 }

}

//===================================================================== b.java //文件名 package nf; //与上一a.java引用同一个包 class B{ static fun2(){

A a= new A()； //通过引用对象 a

a.n2 = a.n4 = a.n3 = 10; //除了用private定义的 n1 //同一个包中，除 private 成员，其他成员都能够访问，因为private 是那个类中私有的，//不能直接访问，如需访问，则需要一个public类型的方法进行中转 } }

//====================================================================== c.java

package nf;

class C extends A{ void fun1{ n2 = n3 = n4 = 10; //同包，且是子类 默认，protected，public 可以直接访问

}

Static fun2(){ A a = new A(); a.n2 = a.n4 = a.n3 = 10;

//此例的C and A 是继承关系，

//但任在同一个包中，所以除 private 成员，其他成员都能够访问 //不能直接访问，如需访问，则需要一个public类型的方法进行中转 } }

//====================================================================== d.java //文件名

package nf.java //在不同包中 class D extends A{ void fun1{ n3 = n4 = 10; //不同包子类可以直接访问父类的 protected 和 public 成员

}

static fun2(){ A a = new A(); a.n4 = a.n3 = 10; //不同包子类中，以引用对象访问父类的 protected 和 public 成员 } }

//====================================================================== e.java //文件名 package nf.java //在不同包中 class E { static fun2(){ A a = new A(); a.n4 = 10; //不同包非子类，依旧能访问public 成员 //private,默认,protected 则不能直接访问

} }

13．Java 中方法的重载：

如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法， 则称为方法的重载，也可称该方法被重载了。 public class HelloWorld { public static void main(String[] args) { // 创建对象 HelloWorld hello = new HelloWorld(); // 调用无参的方法 hello.print(); // 调用带有一个字符串参数的方法 hello.print(\; // 调用带有一个整型参数的方法 hello.print(18); } public void print() { System.out.println(\无参的print方法\ } public void print(String name) { System.out.println(\带有一个字符串参数的print方法，参数值为：\ } public void print(int age) {

System.out.println(\带有一个整型参数的print方法，参数值为：\ }

14.方法和构造方法的区别

1}。方法有返回值类性，方法名小写，不能和类名相同；构造方法没有返回值类型，名与类名相同。

2）构造方法是初始化对象的重要途径，所以就算你给一个类没有定义构造方法，方法在这个类的加载的时候，系统会自动提供一个没有参数的构造方法。

3）他们运行顺序不同，一个类在初始化的时候??

4）方法仅仅是类成员，构造方法也是类成员，但是构造方法有对类属性的初始化功能。 列：public PeoPle(Stting name){this.name = name}

第二季

1．相关概念

1．对象：万物皆对象，客观存在的事物皆为对象

2．面向对象：

3．类：类是模子，确定对象将会拥有的特性（属性）和行为（方法） 4．类的特点：类是对象的类型，具有相同属性和方法的一组对象的集合 5．对象的属性：

属性;对象具有的各种特征，每个对象的每个属性都拥有特定的值 6．对象的方法：（能干什么） 7．方法：对象执行的操作 8．类和对象的关系：

2．定义类

1，类的重要性：所有java程序都以类class为组织单元 2. 什么是类：

类是模子，确定对象将会拥有的特性（属性）和行为（方法） 3. 类的组成：属性和方法。 4. 定义类的步骤： a.定义类名 b.编写类的属性 c.编写类的方法 public class 类名{ //定义属性部分(成员变量) 属性1的类型 属性1; 属性1的类型 属性2; 属性1的类型 属性3; …… 属性1的类型 属性n; //定义方法部分 方法1; 方法2; …… 方法m; }

package dem; //1.定义一个类

public class Telphone { //2.声明一个类的属性（成员变量）属性代一个类有什么 float screen; float cpu; float mem; //3.方法 代表一个类可以干什么 void call(){ System.out.println(\有打电话的功能\ } void sendMessage(){ System.out.println(\有发短信的功能\ } }

【例3.1】自定义一个apple类，在主类SetApple中创建实例并调用方法，输出结果如图3.1所示。源程序代码如下： //程序文件名为SetApple.java public class SetApple {

public static void main(String[] args) { apple a = new apple();//创建apple类 a.appleweight = 0.5;//实例变量赋值 System.out.println(\苹果的重量为1两\ System.out.println(a.bite());//调用实例方法 a.appleweight = 5; System.out.println(\苹果的重量为5两\ System.out.println(a.bite()); } }

//自定义类 class apple {

//属性

long applecolor;//对应苹果的颜色 double appleweight;//苹果的重量 boolean eatup;//是否吃完 //类方法

public boolean bite() { if (appleweight<1) {

System.out.println(\苹果已经吃完了！哈哈\ eatup = true; } else {

System.out.println(\苹果吃不下了！：(\ eatup = false; } return eatup; } }

1. 类声明的基本格式

访问说明符 class 类名 extends 超类名 implements 接口名 其中：

(1) 访问说明符为public或者缺省。public用来声明该类为公有类，可以被别的对象访问。声明为公有的类存储的文件名为类名。

(2) 类名：用户自定义的标识符，用来标志这个类的引用。

(3) 超类名：是指已经存在的类，可以是用户已经定义的，也可以是系统类。 (4) 接口名：即后面讲到的接口。

例如：

public class HelloApplet extends Applet

访问说明符为public，类名HelloApplet，扩展类为JDK包自带的java.applet.Applet类。由于public的存在，所以文件名必须存为HelloApplet.java，同类名保持一致。 2. 类体

类体包括成员变量和方法。

(1) 成员变量：指类的一些属性定义，标志类的静态特征，它的基本格式如下： 访问说明符 数据类型 变量名 其中：

●访问说明符有public、private和protected三种：

public：省略时默认为公有类型，可以由外部对象进行访问。

private：私有类型，只允许在类内部的方法中使用，若从外部访问，必须通过构造函数间接进行。 Protected：受保护类型，子类访问受到限制。

● 数据类型包括基本类型以及用户自定义的扩展类型。

(2) 方法：是类的操作定义，标志类的动态特征，它的基本格式如下：

●访问说明符 数据类型 方法名(数据类型1 变量名1, 数据类型2 变量名2) 其中：

●访问说明符为public、private和protected，其使用方法与成员变量访问说明符的使用方法一致。 ●数据类型：包括基本数据类型和用户自定义的扩展类型。 ●数据类型为参数。 3. 创建类的实例

使用关键字 new进行创建，例如： HelloApplet hp = new HelloApplet(); 3.1.2 类的单继承性

Java编程语言中允许用extends关键字从一个类扩展出一个新类，新类继承超类的成员变量和方法，并可以覆盖方法。

【例3.2】测试类的单继承性，程序输出结果如图3.2所示。源程序代码如下： //程序文件名TestExtend.java

public class TestExtend extends Employee {

public static void main(String[] args) {

System.out.println(\覆盖的方法调用：\王一\ System.out.println(\继承的方法调用：\王一\ System.out.println(\覆盖的方法调用：\王飞\ System.out.println(“继承的方法调用：”+ getSalary2(“王飞\ }

public static String getSalary(String name, int salary) {

String str; if (salary>5000) }

str = \名字: \ Salary: \else str = \名字: \ Salary: 低于5000\return str;

};

class Employee {

public String name;//名字 public int salary;//薪水

public static String getSalary(String name, int salary) { String str;

str = \名字: \ Salary: \ return str; }

public static String getSalary2(String name, int salary) { String str; str = \名字: \ Salary: \ return str; } };

程序中定义了父类Employee类，它有两个方法getSalary和getSalary2，方法体的实现都是一致的，都为输出名字和薪水的值。在TextExtend主类中覆盖了getSalary方法，方法体重新定义为薪水低于5000时并不输出薪水的值而是输出“低于5000”，用于和继承的getSalary2方法进行比较

3.1.3 特殊变量

类中有两个特殊变量super和this。 1. super

类声明中用关键字extends扩展了其超类之后，super用在扩展类中引用其超类中的成员变量。 【例3.3】使用super变量，输出结果如图3.3所示。源程序代码如下： //程序文件名为UseSuper.java public class UseSuper {

public static void main(String[] args) { Manager m = new Manager(); m.name = \王飞\ m.salary = 10000; m.department = \业务部\ System.out.println(m.getSalary()); } }

class Employee {

public String name;//名字 public int salary;//薪水 //方法

public String getSalary() {

String str; str = \名字: \ return str; } }

class Manager extends Employee {

public String department;//部门 //方法

public String getSalary() {

//使用super变量调用超类的方法

return super.getSalary() + \ } }

2. this

this变量指向当前对象或实例。

str = \名字: \上例中的语句可以换成下面的语句。

str = \名字: \

这两者是等同的，因为在Java编程语言中，系统自动将this关键字与当前对象的变量相关联。但有一种情况例外，就是当在某些完全分离的类中调用一个方法并将当前对象的一个引用作为参数传递时。例如： Day d = new Day(this);

3．java 对象

使用对象的步骤： 1.创建对象：（把一个类实例化成对象）

类名 对象名 = new 类名(); Telphone phone = new Telphone(); 2.使用对象： 引用对象的属性：对象名.属性 phone.screen = 5;//给screen属性赋值5 引用对象的方法：对象名.方法名 phone.sendMessage();//调用sendMessage()

1.成员变量： 在类中定义，用来描述对象将要有什么 2.局部变量： 在类的方法中定义，在方法中临时保存数据。 成员变量和局部变量区别 1.作用域不同 2.初始值不同: java会给成员变量一个初始值 java不会给局部变量赋予初始值。

3.在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量。 4.两类变量同名时，局部变量具有更高的优先级

4．成员变量和局部变量

5．构造方法：

1.使用new+构造方法 创建一个新的对象

2.构造方法是定义在java类中的一个用来初始化对象的方法，构造方法与类同名且没有返回值

public 构造方法名(){ //初始化代码 }

没有返回值类型，构造方法名与类名相同，可以指定参数

6．无参构造方法的使用

main():

Telphon phone = new Telphone(); class Telphon:

public Telphone(){ System.out.prinlt(\构造方法执行了\ }

6．带参构造方法的使用

main():

Telphon phone2 = new Telphone(4.0f,2.0f,2.0f); class Telphon:

public Telphone(float newScreen,floatCup,float newMem){ screen = newScreen; cpu = newCpu; mem = newMem; }

创建对象有两种方式： 1.通过无参的构造方法可以创建对象 2.通过有参的构造方法也可以创建对象 3.当没有指定构造方法时，系统会自动添加无参的构造方法 4.当有指定构造方法，无论是有参无参的构造方法，系统都不会自动添加无参的构造方法 5.构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法

6．Java 中的 static 使用之静态变量:

大家都知道，我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是 static 大显身手的时候了！！ Java 中被 static 修饰的成员称为静态成员或类成员。 它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。 静态成员可以使用类名直接访问，也可以使用对象名进行访问。 当然，鉴于他作用的特殊性更推荐用类名访问~~ 使用 static 可以修饰变量、方法和代码块。 public class HelloWorld { // 定义静态变量，保存班级名称 static String className = \开发一班\ public static void main(String[] args) {

// 访问静态变量，输出班级名称 HelloWorld demo = new HelloWorld();

System.out.println(demo.className); }

}

7．Java 中的 static 使用之静态方法

与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。 public class HelloWorld { // 定义静态变量score1 static int score1 = 86; // 定义静态变量score2 static int score2 = 92; }

// 定义静态方法sum，计算成绩总分，并返回总分 public static int sum() { return score1+score2; }

public static void main(String[] args) { // 调用静态方法sum并接收返回值 //使用类名访问静态方法sum并接受返回值 int allScore = HelloWorld.sum(); //使用对象名访问静态方法sum并接收返回值 //HelloWorld demo = new Helloworld(); //int allScore = demo.sum(); }

System.out.println(\总分：\

需要注意：

1. 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。 2.如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量 3. 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量 4. 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。 Java 中的 static 使用之静态初始化块

7． Java 中可以通过初始化块进行数据赋值.如：

public class HelloWorld{

String name;//定义一个成员成员变量 //通过初始化块为成员变量赋值 { name = \爱慕课\ } } 在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。 如果使用 static 修饰初始化块，就称为静态初始化块。 需要特别注意：静态初始化块只在类加载时执行，且只会执行一次， 同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。 public class HelloWorld { String name; // 声明变量name String sex; // 声明变量sex static int age;// 声明静态变量age // 构造方法

}

public HelloWorld() { System.out.println(\通过构造方法初始化name\ name = \}

// 初始化块 { System.out.println(\通过初始化块初始化sex\ sex = \男\}

// 静态初始化块 static{ System.out.println(\通过静态初始化块初始化age\ age = 20; }

public void show() { System.out.println(\姓名：\，性别：\，年龄：\}

public static void main(String[] args) { // 创建对象 HelloWorld hello = new HelloWorld(); }

// 调用对象的show方法 hello.show();

8． 面向对象：

面向对象的三大特性：封装，继承，多态 1.封装：

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。 2.好处：

a.只能通过规定的方法访问数据

b.隐藏类的实例细节，方便修改和实现 3.封装的实现步骤：

1）修改属性的可见性; private

2) 创建getter/setter方法：用于属性的读写 3）在getter/setter方法中加入属性控制语句

package com.imooc; public class Teiphone{ float screen; float cpu; float mem; public Telphone(){ System.out.println(\无参的构造方法执行了\ }

}

封装

package com.imooc; public class Teiphone{

//第一步（封装）

private float screen;//用封装的方式将属性信息隐藏起来，给用户一个特定的方法去访问属性值 private float cpu; private float mem;

//第二部 创建getter/setter方法：用于属性的读写

//如果用户要使用这几个属性，将过get和set方法进行操作 public float getScreen(){ return screen;//得到属性的值 }

//对属性赋值 public void setScreen(float newScreen){//给属性赋值必须传一个参考值，所以要有参数，参数的类型要与属性的类型一致 screen=newScreen; } public Telphone(){ System.out.println(\无参的构造方法执行了\ } public Telphone(float newScreen,float newCpu,float newMem){ screen = newScreen; cpu = newCpu; mem = newMem; System.out.println(\有参的构造方法执行饿了！\ } }

package.com.imooc;

public class InitailTelphon{ public static void main(String[] args){ }

}

//通过无参的构造方法可以创建对象 Telphone phone = new Telphone();

//通过有参的构造方法也可以创建对象 并给对象中的实例变量赋初值 Telphone phone2 = new Telphone(5.0f,1.4f,2.0f);

phone3.setScreen(6.0f);//通过对象名.方法给属性赋值。

System.out.println(\获得属性值

9．Java中的包

1.包的作用： 管理Java文件，解决同名文件冲突。 2.定义包：package 包名 注：必须放在java源程序的第一行 包名间可以使用“.”号隔开 eg:com.imooc.MyClass

3.系统中的包 java.(功能).(类) java.lang.(类)包含java语言基础的类 java.lang.(类)包含java语言中各种工具类 java.io.(类)包含输入，输出相关功能的类 4.包的使用 （1）可以通过import关键字，在某个文件使用其他文件中的类。

10．Java中的访问修饰符

访问修饰符——可以修饰属性和方法。 private 可以修饰属性和方法，只能在本类中访问和使用 默认 什么都不写，只能在当前类的同一包中使用 protected 在本类，同包，子类中都可以使用 public

11．Java 中的this 关键字

1.this关键字代表当前对象 this.属性 操作当前对象的属性 this.方法 调用当前对象的方法

2.封装对象的属性的时候，经常会使用this关键字

12．Java中的内部类

1.内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。 2.内部类的主要作用如下： 1）. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类 2）. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3）. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便 3.内部类可分为以下几种： 成员内部类 静态内部类 方法内部类 匿名内部类

4.我们试着通过一个简单的例子来看一下内部类的使用吧！ //外部类HelloWorld public class HelloWorld { // 内部类Inner，类Inner在类HelloWorld的内部 public class Inner {

// 内部类的方法 public void show() { System.out.println(\ } }

public static void main(String[] args) { // 创建外部类对象 HelloWorld hello = new HelloWorld(); // 创建内部类对象 Inner i = hello.new Inner();

}

}

// 调用内部类对象的方法 i.show();

Java 中的成员内部类

1. 内部类中最常见的就是成员内部类，也称为普通内部类。 我们来看如下代码： //外部类Outer public class Outer { private int a = 99;//外部类的shi有属性 //内部类Inner public void Inner { int b = 2;//内部类的成员 public void test(){ System.out.println(\访问外部类中的a:\ System.out.println(\访问内部类中的b:\ l } //测试成员内部类 public static void main(String[] args) { Outer o = new Outer();//创建外部类对象，对象名为o Inner i = o.new Inner(); //使用外部类对象，对象名为i。 i.test();//调用内部对象的test方法 } } 2.成员内部类的使用方法： 1)、Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置， Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等 2)、Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据， 而不受访问控制符的影响，如直接访问 Outer 类中的私有属性 3)、定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象， 即：内部类 对象名 = 外部类对象.new 内部类( ); 4)、编译上面的程序后，会发现产生了两个 .class 文件?Outer$Inner.class、Outer.class 其中， 第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class 3.外部类是不能直接使用内部类的成员和方法滴

可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

5.如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法， 如果要访问外部类的成员变量，可以使用 this 关键字。如： //外部类Outer public class Outr { int b = i;//外部类中的成员变量b //内部类Inner public class Inner{ int b = 2;//内部类的成员属性b public void test(){

System.out.println(\访问外部类中的b:\Outer.this.b); System.out.println(\访问内部类中的b:\ } } }

6.定义了成员内部类 Inner ，并在内部类的 show 方法中输出外部类和内部类的属性值。 //外部类HelloWorld public class HelloWorld{ }

//外部类的私有属性name private String name = \//外部类的成员属性 int age = 20; //成员内部类Inner public class Inner { String name = \爱慕课\ //内部类中的方法 public void show() {

}

}

System.out.println(\外部类中的name：\HelloWorld.this.name); System.out.println(\内部类中的name：\System.out.println(\外部类中的age：\

//测试成员内部类

public static void main(String[] args) { //创建外部类的对象 HelloWorld o = new HelloWorld (); //创建内部类的对象 Inner inn = o.new Inner(); }

//调用内部类对象的show方法 inn.show();

13．继承

1.继承的概念： 继承是类与类的一种关系，是一种 “is a”的关系 注：Java中的继承是单继承（一个类只有一个父类） 2.继承的好处：

子类拥有父类的所有属性和方法（但是属性和方法的修饰符不能是final，final修饰的属性是不能被继承的）实现代码的复用 3.语法规则：

class 子类 extends 父类

例：class Dog estends Animal{ …… }

14．方法的重写

1.什么是方法的重写： 如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法是会优先调用子类的方法 2.语法规则： a.返回值类型 b.方法名

c.参数类型及个数都要与父类继承的方法相同，才叫方法的重写 3.继承的初始化顺序 1）.初始化父类再初始化子类 2）.先执行初始化对象中属性，再执行构造方法中的初始化 4.final关键字： 使用final关键字做标识有“最终的”含义 final可以修饰类，方法，属性和变量 final修饰类，则该类不允许被继承 final修饰方法，则该方法不允许被覆盖（重写） final修饰属性： 则该类的属性不会进行意识的初始化（类的初始化属性必须有值） 或在构造方法中赋值（但只能选其一） final修饰变量，则该变量的值只能赋一次值，即变为常量 5.super关键字 在对象的内部使用，可以代表父类对象 1）.访问父类的属性 super.age 2).访问父类的方法 super.eat() 3).super的应用

子类的构造的过程中必须调用其父类的构造方法 如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类的构造方法 如果显示的调用构造方法，必须在子类的构造方法的第一行。 如果子类构造方法中既没有显示调用父类的构造方法，而父类有没有无参的构造方法，则编译出错。

14．Object 类

Object 类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个就默认继承Object类。

Object 类中的方法，适合所有子类。 1).toString()方法 在Object类里面定义toSting()方法的时候返回的对象的哈希code吗（对象地址字符串） 可以通过toString()方法表示出对象的属性 没有重写 toString 方法的情况下直接用 print 打印对象，输出的是对象的地址

2）.equals()方法

比较的是对象的应用是否指向同一内存地址。

一般情况下比较两个对象是比较他的值是否一致，所以要进行重写。

14．多态 (继承是多态的实现基础) 在实现多态的时候两个类一定要有继承关系

对象的多种形态 1.引用多态 父类的引用可以指向本类的对象 父类的引用可以指向子类的对象 2.方法多态 创建本类对象时，调用的方法为本类方法 创建子类对象是，调用的方法为子类重写的方法或者继承的方法

3.实例；

//首先创建一个父类Animal public class Animal {

public void eat(){//方法

System.out.println(\动物具有吃的能力\); } }

//创建一个Animal的子类并继承Animal

public class Dog extends Animal {

public void eat(){//在子类中重写eat()方法 System.out.println(\狗是吃肉的\); }

public void watchDoor(){//在子类中添加一个独有的方法，不是从父类中继承来的。 System.out.println(\狗具有看门的能力\); } }

//创建一个Animal的子类并继承Animal public class Cat extends Animal {

}

//创建一个测试类

public class Initail {

/**

* @param args */

public static void main(String[] args) { // TODO Auto-generated method stub /*

Animal obj1 = new Animal();//父类的引用是可以指向本类对象的 Animal obj2 = new Dog();//父类的引用是可以指向子类对象的 Animal obj3 = new Cat();

//Dog obj3 = new Animal();//错 ，因为不能使用一个子类的引用指向父类的对象。 obj1.eat();//调用的是父类中的方法 obj2.eat();//调用的是子类中的方法

obj2.watchDoor();//错 不能通过父类的引用调用子类独有的方法 obj3.eat();//调用的是字子类继承父类的方法

*/

Dog dog = new Dog();//创建一个子类对象 Animal animal = dog;//用一个父类的引用指向子类对象，自动类型提升， 向上类型转换。

自动类型转换

Dog dog2 = animal //再次将父类引用转换成子类引用,是存在风险的，编译器不允许这样的操作 Dog dog2 = (Dog)animal;//向下类型转换，强制类型转换，也是存在风险的

if(animal instanceof Dog){ Dog dog2 = (Dog)animal; }else{

System.out.println(\无法进行类型转换 转换成Dog类型\); }

if(animal instanceof Cat){//如果这个对象里含有Cat类型的元素就可以转换 Cat cat = (Cat)animal;//1.编译时 Cat类 2.运行时 Dog类型 }else{

System.out.println(\无法进行类型转换 转换成Cat类型\); } } }

通过instanceof运算符避免类型转换的安全性为他，它可以判断一个引用是否是某个类型或者某个类型的子类型，他会返回一个布尔值，通常会用这个布尔值跟if语句结合使用 3.多态中的引用类型转换

1）向上类型转换（隐式/自动类型转换），是小类型到大类型的转换（不存在风险） 2）向下类型转换（强制类型转换），是大类型到小类型

3）instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题 Dog dog = new Dog(); Animal animal = dog;//向上类型转换，自动类型转换 Dog dog2 = (Dog)animal;//向下类型转换，强制类型转换 If(animal instanceof Cat){ Cat cat = (Cat)animat;//1.编译时Cat类型 2.运行时Dog类型 }else{ System.out.println(“无法进行类型转换 转换成Cat类型”);

}

15．抽象类（有抽象类和抽象方法）

1.应用场景：（抽象类是约束子类必须那些方法） a. 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这

些方法

b.

从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类的随意性。

2.作用：

限制规定子类必须实现某些方法，但不关注实现细节 3.使用规则：

a. Abstract 定义抽象类

b. abstract 定义抽象方法，只有声明，不需要实现 c. 包含抽象方法的类是抽象类

d. 抽象类中可以包含普通的方法，也可以没有抽象方法 e. 抽象类不能直接创建，可以定义引用变量

如何写一个抽象类：

语法定义：抽象类使用abstract 关键字修饰，则该类为抽象类。

Package com.immoc;

Public abstract class Telphone {//抽象类 } 实例：

//定义一个父类Telphone, 父类只是用来约束子类，所以把他定义成抽象类

Public abstract void call();//抽象方法没有方法体以分号结束 Public abstract void message();

public abstract class Telphone { public abstract void call(); public abstract void message(); }

//早些年的电话，要继承Telphones

public class CellPhone extends Telphone { @Override

public void call() {

// TODO Auto-generated method stub

System.out.println(\通过键盘来打电话\); }

@Override

public void message() {

// TODO Auto-generated method stub

System.out.println(\通过键盘来发短信\); } }

//现在的电话

public class SmartPhone extends Telphone implements IPlayGame{ @Override

public void call() {

// TODO Auto-generated method stub

System.out.println(\通过语音打电话\); }

@Override

public void message() {

// TODO Auto-generated method stub System.out.println(\通过语音发短信\); }

@Override

public void playGame() {

// TODO Auto-generated method stub

System.out.println(\具有了玩游戏的功能\); } }

//定义一个测试类

public class Initail {

/**

* @param args */

public static void main(String[] args) { // TODO Auto-generated method stub

Telphone tel1 = new CellPhone();//使用一个抽象类的父类引用指向一个子类对象，先创建一个普通电话的对象 tel1.call(); tel1.message(); }

}

Telphone tel2 = new SmartPhone();//可以使用父类的引用指向一个智能手机的对象 tel2.call(); tel2.message();

IPlayGame ip1 = new SmartPhone(); ip1.playGame();

IPlayGame ip2 = new Psp(); ip2.playGame();

16．接口（是一种规范，用来约束类的）interface关键字

1.接口概念：

接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成，

类是一种具体实现体，而接口定义了某一批类所需遵守的规范，接口不关心这些类的内部s数据，也不关心这些类里面的方法的实现细节，它只规定这些类里必须提供某些方法。

2.接口定义 和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。 3.接口的基本语法：

[修饰符] interface 接口名 [extends 父接口1，父接口2??] { 零个到多个常量定义?? 零个到多个抽象方法的定义?? }

接口就是用来被继承，被其他类要遵守实现的，修饰符一般建议用public， 注意：不能使用private和protected 修饰接口。

接口里面的内容全都是常量或抽象方法，所以接口的定义也一定有abstract关键字，如果没有显示的把他写出来，那么系统会自动的帮我们加上：

[修饰符] abstract interface 接口名 [extends 父接口1，父接口2??] [extends 父接口1，父接口2??] 接口可以继承多个父接口 []可选项

类在java世界是但继承的，但是接口是可以多继承的。上面再继承的地方用了中括号，表示可以继承父接口也可不继承父接口，是可选的

4.接口定义 常量：（接口中定义的变量都是常量，都会用public static final 来修饰ss） 接口的属性是常量，即使定义是不添加public static final 修饰符，系统也会自动加上。 方法：(接口中的方法都是抽象方法)

接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract 修饰符，系统给也会自动加上。

5．使用接口： 一个类可以实现一个或多个接口，实现借口哦使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以补充。

6.继承父类实现接口的语法： [修饰符] class 类名 xtends 父类 implement 接口1，接口2?? {

类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的方法。 }

多个接口用逗号隔开，类的具体部分如果继承了抽象类就必须实现抽象类里面的抽象方法，如果遵守了一个接口，就必须实现接口中的抽象方法。

如果要继承父类，继承父类必须在实现接口之前（extend要在implements前面） 实例： //定义一个接口

public interface IPlayGame {//省略了abstract关键字 }

//因为智能手既有玩游戏的功能，可以让他实现一个接口，需要用到一个关键字implemention

public void playGame();//省略了abstract关键字

public class SmartPhone extends Telphone implements IPlayGame{

@Override

public void call() {

// TODO Auto-generated method stub

System.out.println(\通过语音打电话\); }

@Override

public void message() {

// TODO Auto-generated method stub System.out.println(\通过语音发短信\); }

@Override

public void playGame() {

// TODO Auto-generated method stub

System.out.println(\具有了玩游戏的功能\); } }

//创建一个psp,因为与电话类没有关系所以不能继承Telphon，具有玩游戏的功能可让他遵循接口

IPlayGame

public class Psp implements IPlayGame { @Override

public void playGame() {

// TODO Auto-generated method stub

System.out.println(\具有了玩游戏的功能\); }

}

//定义一个测试类

public class Initail { /**

* @param args */

public static void main(String[] args) { //

IPlayGame ip1 = new SmartPhone(); ip1.playGame();

IPlayGame ip2 = new Psp(); ip2.playGame(); } }

接口中方法不能有方法体，同时方法的访问修饰符不能是private, protected

第三季

异常：

Exception：编码，环境，用户操作输入出现问题。 RuntimeExeption：非检查异常。 PointerException:空指针异常 ArrayIndexOutOfBoundsException：数组下标越界异常。 ClassCastException:类型转换异常。 ArithmeticException:算数异常。 检查异常： IOException：文件异常。 SQLExcption: SQL异常 处理异常 try{ //一些会抛出异常的方法 }catch(Exception e){ //处理该异常的代码块 }

列子：

try{

System.out.print(“请输入你的年龄：”); Scanner input = new Scanner(System.in);

int age = input.nextInt();

System.out.println(“十年后的你”+(age + 10) + “岁”); }catch (InputMismatchException e){ //从子类到父类，从小到大 System.out.println(“你应该输入整数！”); }

System.out.println(“程序结束了”);

Finally：最终将要执行的代码

Java中的字符串

在 Java 中，字符串被作为 String 类型的对象处理。 String 类位于 java.lang 包中。默认情况下，该包被自动导入所有的程序。

1， 创建string对象的方法：

String s1 = “ imooc ”; //创建一个字符串对象imooc，名为s1 String s2 = new String(); //创建一个空字符串对象，名为S2

String s3 = new String(“imooc”); //创建一个字符串对象imooc，名为S3 字符串的不变性

String 对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。如下所示： String s1 = “爱慕课”; String s2 = “爱慕课”;

String s3 = new String(“爱慕课”); String s4 = new String(“爱慕课”);

//多次出现的字符常量，java编译程序只创建一个，所以返回true System.out .println( s1 = s2 ); //true //s1和s3是不同的对象，所以返回false System.out .println( s1 = s3 ); //false //s3和s4是不同的对象，所以返回false System.out .println( s3 = s4 ); //false

S1 = “欢迎来到：”+ s1;

//字符串s1被修改，指向新的内存空间 System.out .println( s1 );

1. 通过 String s1=\爱慕课\声明了一个字符串对象， s1 存放了到字符串对象的引用，在内存中的存放引用关系如下图所示：

然后通过 s1=\欢迎来到：\改变了字符串 s1 ，其实质是创建了新的字符串对象，变量 s1 指向了新创建的字符串对象，如下图所示：

2、 一旦一个字符串在内存中创建，则这个字符串将不可改变。如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder（后面章节中会讲到）。

3、 每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false” ,如果只需比较内容是否相同，应使用 ”equals()” 方法（前面条件运算符章节讲过哦~~）

实例：

String类的常用方法：

String 类提供了许多用来处理字符串的方法，例如，获取字符串长度、对字符串进行截取、将字符串转换为大写或小写、字符串分割等

结

合

代

码

来

熟

悉

一

下

方

法

的

使

用

：

运行结果

注意：

1. 字符串 str 中字符的索引从0开始，范围为 0 到 str.length()-1

2. 使用 indexOf 进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回 -1

3. 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex

位置的字符 实例：

String类的常用方法II：

我们继续来看 String 类常用的方法，如下代码所示：

运行结果：

那么，“==” 和 equals() 有什么区别呢？

==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象 equals(): 比较存储在两个字符串对象中的内容是否一致

认识 Java 中的 StringBuilder 类

在Java中，除了可以使用 String 类来存储字符串，还可以使用 StringBuilder 类或 StringBuffer 类存储字符串，那么它们之间有什么区别呢？ String 类具有是不可变性。如

运行结果：

从运行结果中我们可以看到，程序运行时会额外创建一个对象，保存 \。当频繁操作字符串时，就会额外产生很多临时变量。使用 StringBuilder 或 StringBuffer 就可以避免这个问题。至于 StringBuilder 和StringBuffer ，它们基本相似，不同之处，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应优先考虑使用 StringBuilder 类。 那么如何定义 StringBuilder 类的对象呢？ 我们来看下面的代码：

运行结果： imooc

接口

接口成员特点:

成员变量: 只能是常量，并且是静态的。 默认修饰符:public static final 建议手动添加方便识别。 构造方法: 接口没有构造方法。 成员方法: 只能是抽象方法。

默认修饰符: public abstract 建议手动添加方便识别。 PS:

所有的类都是默认继承自一个类: Object类，Object 是类层次结构的根类。每一个类都使用Object 作为超类。

类与类:

继承关系，只能单继承，可以多层继承 类与接口:

实现关系，可以单实现，也可以多实现。

并且好可以在继承一个类的同时实现多个接口。 接口与接口:

继承关系，可以单继承，也可以多继承。

接口与接口: 继承关系，可以单继承，也可以多继承 类与接口: 实现关系，可以单实现，也可以多实现,并且好可以在继承一个类的同时实现多个接口。

抽象类和接口的区别： A:成员区别 抽象类：

成员变量：可以变量，可以常量

构造方法：有

成员方法：可以抽象，也可以非抽象 接口：

成员变量：只可以是常量 构造方法：只可以是抽象 B: 设计理念的区别

抽象类 被继承体现的是：“is a”的关系。抽象类中定义的是该继承体系的共性功能。 接口 被实现体现的是：“like a”的关系。接口中定义的是该继承体系的扩展功能。

Java 中的包装类

相信各位小伙伴们对基本数据类型都非常熟悉，例如 int、float、double、boolean、char 等。基本数据类型是不具备对象的特性的，比如基本类型不能调用方法、功能简单。。。，为了让基本数据类型也具备对象的特性， Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。 基本类型和包装类之间的对应关系：

包装类主要提供了两大类方法：

1. 将本类型和其他基本类型进行转换的方法

2. 将字符串和本类型及包装类互相转换的方法 我们将在后面的小节逐步讲解，表着急哦~~

任务

我们以 Integer 包装类为例，来看下包装类的特性。 Integer 包装类的构造方法：

如下代码所示：

Integer包装类的常用方法：

Java 中基本类型和包装类之间的转换

基本类型和包装类之间经常需要互相转换，以 Integer 为例（其他几个包装类的操作雷同哦）：

在 JDK1.5 引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就更加轻松便利了。 那什么是装箱和拆箱呢？我们分别来看下

装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱

拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱

Java 中基本类型和字符串之间的转换

在程序开发中，我们经常需要在基本数据类型和字符串之间进行转换。 其中，基本类型转换为字符串有三种方法： 1. 使用包装类的 toString() 方法 2. 使用String类的 valueOf() 方法

3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

再来看，将字符串转换成基本类型有两种方法： 1. 调用包装类的 parseXxx 静态方法

2. 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱

PS：其他基本类型与字符串的相互转化这里不再一一列出，方法都类似

任务

在编辑器中完成了基本类型和字符串之间的转换。 运行结果为：

参考代码：

使用 Date 和 SimpleDateFormat 类表示时间

在程序开发中，经常需要处理日期和时间的相关数据，此时我们可以使用 java.util 包中的 Date 类。这个类最主要的作用就是获取当前时间，我们来看下 Date 类的使用：

使用 Date 类的默认无参构造方法创建出的对象就代表当前时间，我们可以直接输出 Date 对象显示当前的时间，显示的结果如下：

其中， Wed 代表 Wednesday (星期三)， Jun 代表 June (六月)， 11 代表 11 号， CST 代表 China Standard Time (中国标准时间，也就是北京时间，东八区)。

从上面的输出结果中，我们发现，默认的时间格式不是很友好，与我们日常看到的日期格式不太一样，如果想要按指定的格式进行显示，如 2014-06-11 09:22:30 ，那该怎么做呢？

此时就到了 java.text 包中的 SimpleDateFormat 类大显身手的时候了！！可以使用

SimpleDateFormat 来对日期时间进行格式化，如可以将日期转换为指定格式的文本，也可将文本转换为日期。

1. 使用 format() 方法将日期转换为指定格式的文本

代码中的 “yyyy-MM-dd HH:mm:ss” 为预定义字符串， yyyy 表示四位年， MM 表示两位月份， dd 表示两位日期， HH 表示小时(使用24小时制)， mm 表示分钟， ss 表示秒，这样就指定了转换的目标格式，最后调用 format() 方法将时间转换为指定的格式的字符串。 运行结果： 2014-06-11 09:55:48 2. 使用 parse() 方法将文本转换为日期

代码中的 “yyyy年MM月dd日 HH:mm:ss” 指定了字符串的日期格式，调用 parse() 方法将文本转换为日期。 运行结果： 一定要注意哦：

1、 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理

2、 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包

Calendar 类的应用

Date 类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用 Calendar 类进行时间和日期的处理。

java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();

那么如何使用 Calendar 获取年、月、日、时间等信息呢？我们来看下面的代码：

其中，调用 Calendar 类的 getInstance() 方法获取一个实例，然后通过调用 get() 方法获取日期时间信息，参数为需要获得的字段的值， Calendar.Year 等为 Calendar 类中定义的静态常量。 运行结果：

Calendar 类提供了 getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位。如下所示：

运行结果：

使用 Math 类操作数据

Math 类位于 java.lang 包中，包含用于执行基本数学运算的方法， Math 类的所有方法都是静态方法，所以使用该类中的方法时，可以直接使用类名.方法名，如： Math.round(); 常用的方法：

通过案例我们来认识一下他们的使用吧！！

运行结果：

PS： Math 类还提供了许多其他方法，各位小伙伴们可以注意关注 wiki ，查阅更多信息

集合框架

集合的作用

·在类的内部，对数据进行组织； ·简单而快速的搜索大数量的条目；

·有的集合接口，提供了一系列排列有序的元素，并且可以自序列中间快速的插入或者删除有关元素；

·有的集合接口，提供了额映射关系，可以通过关键字（key）去快速查找对应的唯一对象，而这个关键字可以是任意类型；

与数组de对比—为何选择集合而不是数组

·数组的长度固定，集合的长度可变；

·数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体

对象；

Collection接口，子接口以及实现类

Collection接口

·是List,Set和Queue接口的父接口

·定义了可用于操作List，Set和Queue的方法——增删改查

List接口及其实现类——ArryaList

·List是元素有序并且可以重复的集合，被称为序列

·List可以精确的控制每一个元素的插入位置，或删除某个位置元素 ·ArryaList——数组序列，是List的一个重要实现类 ·ArryaList底层是有数组实现的

各种进制转换

十进制转十六进制

Integer.toHexString(int i);

十进制转八进制

Integer.toOctalString(int i);

十进制转而进制

Integer.toBinaryString(int i);

六十进制转十进制

Integer.valueOf(“FFFF”,16);

Integer.valueOf(“FFFF”,16).toString();

八进制转十进制

Integer.parseInt(“207”,8);

Integer.valueOf(“307”,8).toString();

二进制转十进制

Integer.parseInt(“1011”,2);

Integer.parseInt(“1011”,2).toString();

JDBC

JDBC编程步骤

1:加载驱动程序:Class.forName(driverClass)

加载SQLServer:Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”); 加载Mysql:Class.forName(“com.mysqljdbc.Driver”);

加载Oracle:Class.forName(“oracle.jdbc.driver.OracleDriver”); 2:获得数据库连接:

DriverManager.getConnection(“jdbc.sqlserver://127.0.0.1:1433;databasename=test”,”user”,”password”);

3:创建Statement对象:conn.createStatement();