常用系统类，包，访问控制符
一、 常用系统类
★ Object类
Object类是java中所有类的最终祖先。如果一个类在声明时没有包含extends
（继承）关键字，那么这个类直接继承Object类
★ Random类
Random类提供了一系列用于生成随机数的方法
import java.util.*;
public class Test {
public static void main(String[]args){
Random r = new Random();
int x = r.nextInt();//产生一个int范围内的随机数
System.out.println(x);
int y = r.nextInt(10);//产生0--9直接的一个整数
System.out.println(y);
int z =r.nextInt(10)+1;//产生1--10之间的一个整数
System.out.println(z);
double w =r.nextDouble();//产生0.0--1.0直接的小数
System.out.println(w);
}
}
★ Scanner类
Scanner类可以完成从键盘输入内容
import java.util.*;
public class Test5 {
public static void main(String[] args) {
Scanners = new Scanner(System.in);//创建对象s
//输入整数
System.out.println("请输入你的年龄:");
int a = s.nextInt();
//输入小数
System.out.println("请输入你的体重");
double b = s.nextDouble();
//输入字符串String
System.out.println("请输入你的姓名:");
Stringc = s.next();
System.out.println("姓名:"+c+",年龄:"+a+",体重:"+b);
}
}
★ Math类
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。Math类中所有方法都是静态方法。
public class Test6 {
public static void main(String[] args) {
System.out.println(Math.E);//访问属性
System.out.println(Math.PI);
int x = Math.abs(-10);//调用方法
System.out.println(x);
double y = Math.pow(5, 3);//调用方法
System.out.println(y);
}
}
★ Arrays类
此类包含用来操作数组（比如排序和搜索）的各种方法。
import java.util.Arrays;
public class Test7 {
public static void main(String[]args) {
int[] a ={26,89,45,69,95,60};
Arrays.sort(a);//调用方法
//输出数组
for(int i = 0;i<=a.length-1;i++){
System.out.print(a[i]+" ");
}
System.out.println();
}
}
★ Date类、DataFormat、SimpleDateFormat类
(后面专题讲解)
多态:多种形态
Java中引用类型变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由申明该变量时使用的类型决定，运行时有实际赋给该变量的对象决定。如果运行类型和编译类型不一致,这就是多态。
多态分为以下两种形式：
★方法的重载与重写(覆写/覆盖)
静态多态(编译时多态):方法重载
动态多态(运动时多态):方法重写
★ 对象的多态
向上转型:子类对象---à父类对象格式:父类父类对象 = 子类对象
向下转型:父类对象---à子类对象格式:子类子类对象 = （子类）父类对象
一、 两种类型的多态
★方法的重载与重写(覆写)
●方法重载
方法的重载指的是，在同一个类中，允许多个方法名相同，参数列表不同（类型，个数，顺序）即可，与访问控制符，返回值，异常无关。
package test_11_18;
public class TestAdd {
public static void add(int a,int b){
System.out.println(a+b);
}
public static void add(int a,int b,int c){
System.out.println(a+b+c);
}
public static void add(double a,double b){
System.out.println(a+b);
}
public static void add(double a,double b,double c){
System.out.println(a+b+c);
}
public static void main(String[] args){
add(5,6);//系统根据你传入的参数自动找到匹配的方法
add(1.1,2.2,3.3);
}
}
●方法重写(覆盖、覆写)
方法的重写指的是，在继承中如果父类中某个方法不能满足子类的需求，子类可以重写父类中的该方法。重写时(在子类中写)，方法名、返回值类型、参数列表都必须和父类中该方法一样，子类中的访问控制符不能比父类更严格。如果父类中的该方法使用private修饰，在子类中就不叫重写（因为子类根本无法访问该方法）。
package test_11_15;
public class People {
public String name;
public char sex;
public int age;
public void printInfo(){
System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age);
}
}
package test_11_15;
public class Student extends People{
public String no;
public void printInfo(){//重写
System.out.println("学号:"+no+",姓名:"+name+",性别:"+sex+",年龄:"+age);
}
public static void main(String[] args){
Student s = new Student();
s.name = "小明";
s.sex = '男';
s.age = 18;
s.no = "IBM1300101";
s.printInfo();
}
}
重载重写对比
|
| 位置 | 方法名 | 参数列表 | 返回值 | 访问控制符 |
| 重载 | 同一类中 | 一样 | 不一样 | 无关 | 无关 |
| 重写 | 父类和子类 | 一样 | 一样 | 一样 | 子类不能比父类严格 |
Object类是所有类的基类，一个类如果没有显示继承其他类，则默认继承Object。重写Object类中的toString()和equals()就是很经典的方法重写，很多类中都对Object类中的这两个方法进行了重写。例如String类中。
package test_11_18;
public class People {
public String name;
public char sex;
public int age;
public String toString(){//重写Object中的toString()方法
String s = name+","+sex+","+age+"岁";
return s;
}
public static void main(String[] args) {
People p = new People();
p.name = "小明";
p.sex = '男';
p.age = 15;
System.out.println(p);//直接输出对象p，相当于调用 p.toString();
}
}
运行结果: 小明,男,15岁
说明:如果People类没有重写String类中的toString()方法，则输出结果肯定是: test_11_18.People@c17164(地址)，但是在此案例People类中重写了Object类中的toString()方法，所以直接输出对象p结果是:小明,男,15岁
★对象多态
●向上转型
语法: 父类父类对象 = 子类对象
package test_11_29;
public class A {
public void fun1(){
System.out.println("A类的fun1");
}
public void fun2(){
System.out.println("A类的fun2");
}
}
package test_11_29;
public class B extends A{
public void fun1(){
System.out.println("B类的fun1");
}
public void fun3(){
System.out.println("B类的fun3");
}
}
package test_11_29;
public class Test {
public static void main(String[] args) {
B b = new B();// int a = 10;
A a = b;//double b = a;
a.fun1();
a.fun2();
}
}
运行结果:
B类的fun1
A类的fun2
分析:对象向上转型，此时a编译时是A类型对象，运行时是B类型对象。
此时a.fun1()看起来是A类对象调用的fun1（），但是实际上调用的是B类中重写的fun1（）
总结:
发生对象向上转型，调用方法时，如果子类重写了该方法，则调用的是子类重写后的方法；如果子类没有重写该方法，才调用自己的。
但是此时对象a无法调用fun3（），因为此方法只在B类中定义了而未在A类中定义。如果想调用B类中定义的fun3（）,此时需要完成向下转型。
●向下转型
语法: 子类子类对象 = （子类）父类对象
package test_11_29;
public class A {
public void fun1(){
System.out.println("A类的fun1");
}
public void fun2(){
System.out.println("A类的fun2");
}
}
package test_11_29;
public class B extends A{
public void fun1(){
System.out.println("B类的fun1");
}
public void fun3(){
System.out.println("B类的fun3");
}
}
package test_11_29;
public class Test {
public static void main(String[] args) {
A a = new B();//向上转型
B b = (B)a;//向下转型
b.fun1();
b.fun2();
b.fun3();
}
}
运行结果:
B类的fun1
A类的fun2
B类的fun3
分析:子类是一个特殊的父类，因此java中允许将一个子类对象直接赋给一个父类对象，可以自动完成向上转型，编译时是父类，运行时依旧是子类的特征。Java中也可以向下转型，但是向下转型前必须完成一次向上转型。
A a = new A();
B b = (B)a;// 运行时会报错
第九讲 抽象类
二、 抽象类的作用
通过继承可以从原有的类派生出新的类，原有的类称为基类或父类，而新的类称为派生类或子类。通过继承机制，派生出来的新类不仅可以保留父类的属性和方法，还可以拥有自己的属性和方法。
Java中有一种特殊的类专门用来做父类，这种类称为“抽象类”.抽象类像模板一样，他的目的是要设计者依据他的格式来进行修改并创建新的类。但是抽象类自身不能创建对象，只能通过抽象类派生出来的子类创建对象。抽象类也只能单继承。
三、 抽象类的特点
1. 包含抽象方法的类必定是抽象类，但是抽象类不一定包含抽象方法。
2. 抽象类和抽象方法都必须要使用关键字abstract修饰
3. 构造方法，静态方法不能声明为抽象方法
4. 抽象方法不能使用private修饰
5. 抽象方法只需要声明不需要实现
6. 抽象类不能创建对象，无法使用new关键字调用抽象方法的构造方法创建对象。即使抽象类中包含构造方法该类也不能创建对象。
7. 子类继承抽象类时，必须要重写抽象类中的所有抽象方法（如果子类也是抽象类可以不重写）
四、 抽象类的语法
语法:
[修饰符] abstract class 类名{
属性;
构造方法;
[访问控制符] 返回值类型方法名([参数列表]){
//方法体
}
[访问控制符] abstract返回值类型方法名([参数列表]);
}
案例:
案例一:
案例二:
第十讲 接口
一 接口
接口就是一组对类的要求，它反映了一组没有内在联系、不相关的类之间的通讯的协议
接口支持多继承。
二 接口的特点
1. 一个类只能直接继承一个父类，但是可以实现多个接口。
2. 接口不能实例化、接口没有构造方法。
3. 接口中的方法全部都是抽象方法，常量全部都是静态常量。
4. 当一个类实现某个接口时，它必须实现该类中的所有的抽象方法，除非这个类定义为抽象类。
三 接口的语法
语法:
[访问控制符] interface 接口名{
全局常量;
抽象方法;
}
案例:
四 接口的使用
案例一:
案例二:实现多个接口(多继承)
补充:
● 类实现多个接口
class 类名 implements 接口1,接口2……{
}
● 类实现接口同时又继承类
class 类名 extends 父类 implements 接口1,接口2……{
}
● 接口继承接口(接口只能继承接口，不可以继承类。而且接口继承接口使用extends，而且接口可以继承多个接口)
案例一:接口继承接口
interface A{
voidfun1();
}
interface B extends A{
voidfun2();
voidfun3();
}
案例二:接口继承多个接口
interface A{
voidfun1();
}
interface B{
voidfun2();
voidfun3();
}
interface C extends A,B{
}
第十一讲 包装类
五、 理解包装类
Java语言是一门面向对象的语言，但是他又包含了八种基本数据类型，这八种基本数据类型不支持面向对象的编程机制，(面向对象中，对象可以拥有属性和方法)。Java为什么要保留八种基本数据类型呢?主要是为了照顾程序员的习惯。
八种基本数据类型给编程带来了方便，但是同时他又破坏了面向对象的特点。为了解决这个矛盾，java中提供了包装类。
六、 八种基本数据类型对应的包装类
基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
除了int、char其他的都是把首字母改大写
Byte 、Short 、Integer、 Long、 Float 、Double 都是Number类的子类
Character Boolean是Object类的子类
一、 基本数据类型与包装类的转换
★在JDK1.5之前
**基本数据类型变量---->包装类对象 通过包装类中的构造方法完成
包装类除了Character外都有两个构造方法，一个是传相应的基本数据类型变量，一个是传String类型的对象
int a = 5;
Integeri = new Integer(a);//基本数据类型变量a----->包装类型对象i
Strings = "123";
Integer i = new Integer(s);//注意字符串不可以随意乱写
System.out.println(i);
**包装类对象----->基本数据类型变量通过使用包装类对象的XXXValue()方法完成
Double d = new Double(5.5);
doubleb = d.doubleValue();
System.out.println(b);
Integeri = new Integer(5);
inta = i.intValue();
System.out.println(a);
★在JDK1.5之后
从前面可以看出，基本数据类型和包装类的转换还是有些麻烦，JDK1.5之后提供了自动拆箱和自动装箱机制
自动装箱: 把基本数据类型变量直接赋给一个包装类型的对象，或者直接给到Object类型的对象。
int a = 5;
Integeri2 = a;//自动装箱
Objectobj = 5;//自动装箱
自动拆箱: 把包装类的对象直接赋给一个基本数据类型的变量
案例：
publicclass Test1 {
publicstatic void main(String[] args){
Integeri = 5;//自动装箱(基本数据类型---->包装类)
inta = i; //自动拆箱(包装类---->基本数据类型)
Objectobj = 5.5;//自动装箱
}
}
★instanceof语法:
对象名 instanceof 类名 //如果对象和类匹配则为true 否则值为false
七、 字符串与基本数据类型的转换
**String类型对象---->基本数据类型变量
使用基本数据类型对应的包装类中的parseXXX()方法完成
String s = "123";
int a = Integer.parseInt(s);
String s1 ="123.456";
double d =Double.parseDouble(s1);
**基本数据类型变量---->String类型对象
使用String类中的valueOf()方法完成
int a1 = 123;
double b1 = 123.123;
String s2 =String.valueOf(a1);//String s2 = a1+"";
String s3 =String.valueOf(b1);
public class Test1 {
public static void main(String[] args) {
//字符串---》基本类型
String s = "123";
int a = Integer.valueOf(s);
int b = Integer.parseInt(s);
System.out.println(a+" "+b);
//基本类型--->字符串
int x = 10;
String s1 = String.valueOf(x);
String s2 = x+"";
System.out.println(s1+" "+s2);
}
}
第五章 异常处理
一、 异常的概念
异常:运行时发生的错误称为异常。
eg：数组下标越界
文件不存在
除数为0....
异常处理:处理这些异常就称为异常处理。
一旦引发异常，程序将突然中止，且控制将返回操作系统。
二、 异常处理的方法
Java中异常处理机制如下
1.在Java程序的执行过程中，如果出现了异常事件，就会生成一个 异常对象。
2.生成的异常对象将传递给Java运行时系统（JRE），这一异常的产生和提交过程称为“抛出(throw)异常”。
3.当JRE得到一个异常对象时，它首先寻找处理此异常的代码。如果找到能够处理这种类型异常的方法后，JRE把当前异常对象交给这个方法进行处理，这一过程称为捕获(catch)异常。
4.如果JRE找不到可以捕获异常的方法，则JRE将终止，相应的Java程序也将退出。
Error
一般不能由应用程序直接处理，必须交由操作系统处理。（硬件原因造成的运行错误）
运行时异常
RuntimeException的子类异常。Java编译器允许程序不对它们做出处理。
非运行时异常
除了运行时异常之外的其他由Exception继承来的异常类。Java编译器要求程序必须捕获或声明这种异常，否则编译就报错。
三、 Try、catch、finally、throws、throw五个关键字
Java 中可用于处理异常的两种方式：
自行处理：可能引发异常的语句封入在 try 块内，而处理异常的相应语句则封入在 catch 块内。
回避异常：在方法声明中包含 throws 子句，通知潜在调用者，如果发生了异常，必须由调用者处理。
★try...catch
形式一:最基本的异常处理
try{
可能发生异常的代码块;
}catch(Exceptione){
异常处理
}
补充:
catch块中的异常处理一般有两种形式
1.System.err.println();输出异常信息
2.e.printStackTrace();建议使用这种
★finally
形式二:如果有些代码无论发生什么情况都需要执行，可以把这些代码放到finally块中
例如:数据库的关闭，网络的关闭等等....
try{
可能发生异常的代码块;
}catch(Exceptione){
异常处理代码块;
}finally{
一定需要执行的代码块;
}
注意:多重catch时，异常子类一定要位于异常父类之前
try{
…...
}catch(Exception e) {
……
}catch(ArrayIndexOutOfBoundsException e) {//此处报错，因为前面catch可以捕获所有异常，此处代码没用
……
}
★throws throw
public class TestException {
publicstatic void main(String[] args){
System.out.println("Hello");
try{
thrownew Exception("自己显示抛出的异常");//显示抛出异常
}catch (Exception e) {
e.printStackTrace();
}
}
}
importjava.io.*;
public classTest1 {
publicstatic void fun() throws FileNotFoundException{
//fun()方法中，会有异常，但是它抛出了异常，此异常给到调用他的方法处理。
FileInputStreamfis = new FileInputStream("D:\\1.txt");
}
publicstatic void main(String[] args){
try{
fun();//main方法中调用了fun(),必须要处理fun()中抛出的异常
//main方法可以继续抛出(给到虚拟机处理)，也可以用try...catch捕获
}catch (FileNotFoundException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
四、 自定义异常
JavaAPI提供的内置异常不一定总能捕获程序中发生的所有错误。有时会需要创建用户自定义异常
自定义异常需要继承Exception 及其子类
案例:
classMyException extends Exception{/自定义异常
publicMyException(){
super("我自己定义的异常!");
}
}
public classTestException {
publicstatic void main(String[] args){
try{
thrownew MyException();
}catch (Exception e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
第九章 多线程
一、 线程的概念
程序:
程序其实就是一段静态的代码，他是进程执行的蓝本。
进程:
进程就是程序的一次动态执行。(在操作系统中，程序并不能单独的执行，作为资源分配和独立 运行的基本单位都是进程。进程是一个具有一定独立功能的程序关于某个数据集合的动态执行过程.进程是操作系统进行调度和资源分配的基本单位。)
进程特点:
1.动态性:进程与程序的区别在于程序只是一段静态的代码，而进程是代码的动态执行。
2.并发性:多个进程在一个CUP中并发执行。(一个CPU在某一个时刻只能做一件事情，我们为什么可以同 时使用QQ，Word,听音乐...其实是CPU在多个进程中不停的切换，只不过CPU速度很快，我们感觉是同时执行)
3.独立性:进程是系统中进行调度和资源分配的基本单位，每个进程都可以拥有自己的资源，自己的空间，进程单独执行
线程:(子进程)
线程是进程内部的一个执行单元。他是程序中的一个单一的流程控制。如果在一个进程中 同时运行多条线程，就叫做多线程。(eg：eclipse软件执行起来就是一条进程，eclipse中可 以同时敲代码，还可以同时代码提醒，代码错误检测...这就是多线程。)
二、 创建多线程的两种方法
★1.继承Thread类，重写run方法。
语法:
classTest extends Thread{
//重写run方法
public void run(){
//方法体
}
}
★2.实现Runnable接口，实现run方法。
语法:
classTest implements Runnable{
//实现run方法
public void run(){
//方法体
}
}
启动线程:
新建的线程不会自动启动，必须通过start()方法启动(注意：不要直接调用run()方法，直接调用run方法不会启动线程，而变成普通的方法调用，记住多线程中永远不要调用run方法)
方法一:
Test t = new Test();
t.start();//启动线程
方法二:
Test t = new Test();
Thread th = new Thread(t);
th.start();//启动线程
注意:一条线程不能启动多次，否则会报IllegalThreadStateException异常。
/**
* 继承Thread类实现多线程
*/
package test_12_2;
public class Test1 extends Thread{
public void run() {
while(true){
System.out.println("******************乌龟领先了,真棒!继续保持!");
}
}
public static void main(String[] args) {
Test1 t = new Test1();
t.start();//启动线程(注意启动线程不能直接调用run方法，必须调用start)
while(true){
System.out.println("兔子领先了,别骄傲!");
}
}
}
/**
* 实现Runnable接口完成多线程
*/
package test_12_2;
public class Test2 implements Runnable{
public void run() {
while(true){
System.out.println("******************乌龟领先了,真棒!继续保持!");
}
}
public static void main(String[] args) {
Test2 t = new Test2();
Thread th = new Thread(t);//将t构造成一个线程对象
th.start();//启动线程
while(true){
System.out.println("兔子领先了,别骄傲!");
}
}
}
说明:
Java程序运行时，会立即创建主线程（main），如果程序没有启动其他线程，则改程序就是单线程；如果启动了新线程，则该程序就是多线程。
两种创建线程的方法对比:
|
| 优点 | 缺点 |
| 继承Thread类 | 简单 | 不可以再继承其他类 无法实现资源共享 |
| 实现Runnable接口 | 可以继承其他类 可以实现资源共享 | 复杂 |
资源共享案例:
package test_12_2;
public class Test3 extends Thread{
public int tickets = 10;
public void run() {
while(tickets>0){
System.out.println(this.getName()+"----卖票"+tickets--);
}
}
public static void main(String[] args) {
Test3 t1 = new Test3();
Test3 t2 = new Test3();
Test3 t3 = new Test3();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
运行结果:三个窗口，各自卖了10张票，没有实现资源共享
package test_12_2;
public class Test4 implements Runnable{
public int tickets = 10;
public void run() {
while(tickets>0){
System.out.println(Thread.currentThread().getName()+"----卖票"+tickets--);
}
}
public static void main(String[] args) {
Test4 t = new Test4();
Thread th1 = new Thread(t,"窗口1");
Thread th2 = new Thread(t,"窗口2");
Thread th3 = new Thread(t,"窗口3");
//th1.setName("窗口1");
//th2.setName("窗口2");
//th3.setName("窗口3");
th1.start();
th2.start();
th3.start();
}
}
运行结果:三个窗口，共同卖了10张票，实现资源共享
一、 线程生命周期
1570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
