#java基础
一：java语言优点：
- 简单性 一切皆对象，所以不需要指针，Java能够自动处理对象以及间接引用，用户不必为存储问题所烦恼，能够花费更多的精力在研发上。
- 纯面对对象 在一个面对对象的系统中，数据和方法被描述为状态以及行为，每一个对象是其状态以及行为的封装，java程序是用 类来组织的。
- 编译以及解释性 Java编译生成 字节码文件，程序开发速度快。
- 稳健性 Java是 强类型语言，做出的产品能够捕捉调用错误，做出的产品更加稳健可靠。
- 安全性 Java没有指针，开发者不能 隐藏内幕以及
伪造指针。程序员不能通过申明取猜测Java类的实际存储安排。 - 可移植性 Java语言申明不依赖于实现方面，程序一次编写，各处运行。
- 分布式 Java 语言支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段。
- 高性能 Java是一种先编译和解释的静态强类型语言，在编译型语言写的程序执行之前，需要一个专门的编译过程，把源代码编译成机器语言的文件，如exe格式的文件，以后要再运行时，直接使用编译结果即可，如直接运行exe文件。因为只需编译一次，以后运行时不需要编译，所以
编译型语言执行效率高。 - 多线程 在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有两种方法来创建线程：其一，
使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。
值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。 - 类库丰富
- Java 语言是动态的：Java 语言的设计目标之一是适应于动态变化的环境。Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
二.编译语言的执行方式：
三.解释性语言的执行方式：
四，自我理解：
面对对象吧，不仅仅吸收了C++语言的优点，而且还摒弃了多类继承以及指针。可以说java语言就是
C++语言改进的一门高级编程语言。
五，Java语言的环境：
**JRE**指的是 **Java Runtime Enviroment（java运行环境）**，包括Java虚拟机（JVM:Java Virtual Machine）和Java程序所需要的核心类库。
**JDK**（Java Development Kit， **Java开发工具包**）JDK是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括JRE。因此安装JDK便不需要再单独安装JRE。（开发工具包括编译工具：java.exe和打包工具：jar.exe等）。
**JDK：JRE+JAVA开发工具**
六，第一个Java程序
class Demo{
public static void main(String[] args){
System.out.println("Hello World");
}
}
关键词解释
- static: static声明的成员变量为 静态成员变量 ，也成为类变量。类变量的生命周期和类相同，在整个 应用程序执行期间都有效: 。
- void: void就是空，在方法申明的时候 表示该方法没有返回值 。
- String [ ] args: String与String[], 前者叫字符串类型而后者叫字符串数组类型，类型上就可以直接看出变量为一数组类型引用。
基本语法
- 大小写敏感
- 类名首字母大写
- 所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
- 源文件名 必须和类名相同。
- 所有的 Java 程序由 public static void main(String[ ] args) 方法开始执行。
七,Java修饰符
像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：
- 访问控制修饰符 : default, public , protected, private
- 非访问控制修饰符 : final, abstract, static, synchronized
修饰符解释:
- default: 即不加任何访问修饰符，通常称为“默认访问权限“或者“包访问权限”。该模式下，只允许在同一个包中进行访问。
- protected: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护访问权限 ”。被其修饰的属性以及方法只能被类本身的方法及子类访问 ，即使子类在不同的包中也可以访问。
- private: java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象访问，
其子类不能访问，更不能允许跨包访问。
- final : 用final修饰类时，被修饰的类不可以被继承。final类中的所有成员方法都会被隐式地指定为final方法。被修饰的方法不能被重写。如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
- synchronized: Java 语言中用 synchronized 修饰方法和代码块来控制在同一时刻只有一个线程执行该段代码，从而保证多并发情况下的数据安全。简单讲 synchronized 就是给修饰的方法或代码块声明一个锁，拥有这个锁的线程可以执行区块里面的指令，其他的线程只能等待获取锁，然后才能执行相同的操作。用synchronized 修饰方法和代码块通常被称为“加锁”。
- static: static声明的成员变量为 静态成员变量 ，也成为类变量。类变量的生命周期和类相同，在整个 应用程序执行期间都有效: 。
- enum : enum 指枚举类型。（1） enum修饰的类不能被其他类继承 ，也不能继承其他类。原因在于，enum默认继承了Enum类，所以不能多重继承，而被enum修饰的类默认为final的，所以也不能衍生出子类。
enum类中的元素定义必须写在所有其他部分（例如定义成员变量，定义构造方法，定义成员方法）前面 ，否则编译器会报错。
//抽象关键词使用：
/**
* 车子类
*/
public abstract class Car {
public abstract void run();
}
/**
* 自行车
*/
class Bicycle extends Car{
@Override
public void run() {
System.out.println("人踩着跑。。。");
}
}
/***
* 汽车
*/
class Automobile extends Car{
@Override
public void run() {
System.out.println("发动机驱动跑。。。");
}
}
解释：
1、从上面的例子中我们可以看到抽象方法跟普通方法是有区别的，它没有自己的主体（没有{}包起来的
业务逻辑），跟接口中的方法有点类似。所以我们没法直接调用抽象方法2、抽象方法不能用private修饰，因为抽象方法必须被子类实现（覆写），而private权限对于子类来
说是不能访问的，所以就会产生矛盾3、抽象方法也不能用static修饰，试想一下，如果用static修饰了，那么我们可以直接通过类名调
用，而抽象方法压根就没有主体，没有任何业务逻辑，这样就毫无意义了。
解释：
1、用abstract关键字来表达的类，其表达形式为：（public）abstract class 类名{}2、抽象类不能被实例化，也就是说我们没法直接new 一个抽象类。抽象类本身就代表了一个类型，无法
确定为一个具体的对象，所以不能实例化就合乎情理了，只能有它的继承类实例化。3、抽象类虽然不能被实例化，但有自己的构造方法（这个后面再讨论）
4、抽象类与接口（interface）有很大的不同之处，接口中不能有实例方法去实现业务逻辑，而抽象类
中可以有实例方法，并实现业务逻辑，比如我们可以在抽象类中创建和销毁一个线程池。5、抽象类不能使用final关键字修饰，因为final修饰的类是无法被继承，而对于抽象类来说就是
需要通过继承去实现抽象方法，这又会产生矛盾。（后面将写一篇关于finally的文章详细讨论）6、如果一个类中至少有一个抽象方法，那么这个类一定是抽象类，但反之则不然。也就是说一个抽象类中可
以没有抽象方法。这样做的目的是为了此类不能被实例化。7、 ? 如果一个类继承了一个抽象类，那么它必须全部覆写抽象类中的抽象方法 ?，当然也可以不全部覆写，如果
不覆写全部抽象方法则这个子类也必须是抽象类（这样做就无意义了）
//抽象关键词使用：
public abstract class Car {
public void mothod1(){
}
public abstract void mothod2();
public abstract void method3();
}
class Bicycle extends Car{
@Override
public void mothod2() {//需要覆写抽象方法mothod2
}
@Override
public void method3() {//需要覆写抽象方法mothod3
}
}
public abstract class Car {
Car(){
System.out.println("抽象方法无参构造函数");
}
Car(String a){
System.out.println("抽象有参构造方法");
}
public void mothod1(){
System.out.println(this.getClass());
System.out.println("抽象类的实例方法");
}
public abstract void mothod2();
}
/**
* 自行车
*/
class Bicycle extends Car{
Bicycle(){
System.out.println("子类无参构造函数");
}
@Override
public void mothod2() {//需要覆写抽象方法mothod2
}
}
/**另一个包的测试类**/
public class Test {
public static void main(String[] args) {
Bicycle b = new Bicycle();
b.mothod1();
}
}
结果：
抽象方法无参构造函数
子类无参构造函数
class com.shaolin.service.impl.Bicycle
抽象类的实例方法
1、抽象类是有构造方法的（当然如果我们不写，编译器会自动默认一个无参构造方法）。而且从结果来看，和普通的继承类一样，在new 一个子类对象时会优先调用父类（这里指的是抽象类Car）的构造器初始化，然后再调用子类的构造器。至此相信大家都会有这样一个疑问，为什么抽象方法不能实例化却有构造器呢？ 对于这个问题网上也中说纷纭，没有确定答案。
我是这样想的：既然它也属于继承的范畴，那么当子类创建对象时必然要优先初始化父类的属性变量和实例方法，不然子类怎么继承和调用呢？而它本身不能实例化，因为它本身就是不确定的一个对象，如果它能被实例化，那么我们通过它的对象来调用它本身的抽象方法是不是有问题。所以不能实例化有在情理之中。因此大家只要记住这个规定就行。
2、对于抽象类中的非statci(静态)和非abstract(抽象)方法中的this关键字（静态方法中不能有关键字this之前已经讨论过可以参考 关于静态static那些事）代表的是它的继承类，而非抽象类本身，这个好理解，因为抽象类本身不能被实例化。如果有多个继承类，谁调用this就代表谁。
抽象类有什么好处呢？
- 1、由于抽象类不能被实例化，最大的好处就是通过方法的覆盖来 实现多态的属性
。也就是运行期绑定- 2、抽象类将事物的共性的东西提取出来，由子类继承去实现，代码易扩展、易维护。
八、Java 变量
java主要分为以下几种变量：
- 局部 变量
- 类变量（静态变量）
- 成员变量（非静态变量）
九、Java 其他关键字
1）类方法修饰符
- extends:扩充,继承
- final: 最终值,不可改变的
- interface: 接口
- native： 本地，原生方法（非 Java 实现）
- synchronized: 线程,同步
2）控制块关键词
- break:跳出循环
- case：定义一个值供swicth选择
- continue：继续
- default:默认
- do： 运行
- return：返回
- while：循环
3）错误处理
- assert：断言是否为真
- catch：捕捉异常
- finally：有没有异常都执行
- throw：抛出一个异常对象
- try：捕捉异常对象
4）包相关
- import：引入
- package：包
- Boolean：布尔型
- byte：字节型
- char:字符型
- double:双精度浮点型
- float：单精度浮点型
- int:整型
- long:长整型
- short:短整型
- super：父类，超类
- this：本类
- void:无返回值
- goto、const： 是关键字，但不能使用
十、继承
在Java中，一个类可以派生其他类，如果已存在的类具有你所需要的属性以及方法，那么你可以选取新类继承父类。利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
十一、接口
在 Java 中，接口可理解为 对象间相互通信的协议。接口在继承中扮演着很重要的角色。
十二、Java 源程序与编译型运行区别
十三、Java 修饰符以及变量
- 在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似。
int a, b, c; // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = "runoob"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。
####Java语言支持的变量类型有：
- 类变量：独立于方法外的变量，用static修饰。
- 实例变量：独立于方法之外的变量，不过不许static修饰。
- 局部变量，类中的方法变量。
//实例
public class Vaiable{
static int allclicks=0;//类变量
String str="hello world!";//实例变量
public void method(){
int i=0;//局部变量
}
}
java中局部变量的理解
- 局部变量声明在方法或者构造方法的语句块中；
- 局部变量执行完后将被销毁；
- ？访问修饰符不能用于局部变量 ？；
- 局部变量只在声明方法，构造方法以及语句块中 出现；
- 局部变量实在栈上分配的；
- 局部变量没有默认值，所以在申明之后，要经过初始化后才能使用。
？java中实例变量的理解？
- 实例变量声明在一个类中，但是在方法中，构造方法中和语句块之外；
- 当一个对象被实例化，每个实例变量的值就会随之确定。
- 实例变量在实例对象创建时创建，在对象被销毁时候被销毁；
- 实例变量至少被一个方法，构造方法或者语句块来引用，是得外部能够通过这些方式来获取这种信息；
- 实例变量可以在声明前以及声明后使用；
- 访问修饰符可以访问实例变量；
- 实例变量对于类中的构造方法，方法以及语句块来说是可见的，一般来说应该吧实例变量设置为私有，通过访问
修饰符可以是得实例变量对子类可见。- 实例变量具有默认值，数值类型默认值为0，布尔类型默认值为false，引用变量的默认值为null，变量的值
可以在声明前指定，也可以在构造方法中指定。
？java中静态变量(类变量)的理解？
- 类变量也叫做静态变量，用static声明，必须在方法之外；
- 无论类创建了多少变量，类只拥有类变量的一份拷贝；
- 静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
- 静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
- 静态变量在第一次被访问时创建，在程序结束时销毁。
- 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。
java修饰符
java修饰符包括两类，访问修饰符以及非访问修饰符。
访问控制修饰符
- defauit： 同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
- private： 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
- pubic： 对所有类可见。使用对象：类、接口、变量、方法。
- protected: 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
非访问修饰符
static，用于修饰类方法以及类变量
final，用于修饰类，方法以及变量，final修饰类不能被继承，修饰方法则不能被重新定义，修饰量则是常量不可修改！
abstract，用于修饰抽象类以及抽象方法。
synchronized、volatile，主要用于线程以及编程。
十四、java运算符
####1.运算符种类
- 算术运算符 +、-、*、/、%（取余）、++（自增）、–（自减）。
- 关系运算符 ==、！=、>、<、>=、<=。
- 位运算符 &(和运算符，仅仅相应为 都是1，结果才是1，其他都是0)，|（或运算符），~(与非)，^(如果相对应位值相同，则结果为0，否则为1)
- 逻辑运算符 &&(称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。) 。||(称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。) ！(称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。)
- 赋值运算符
- =
- +=
- -=
- *=
- /=
- (%)=
- <<=
- >>=
- &= 按位与赋值运算符
- ^= 按位异或赋值操作符
- |= 按位或赋值操作符
- 其他运算符
- 条件运算符为三元运算符，该运算符有三个操作数，？与：是运算符的组成。
//举例：
public class Test {
public static void main(String[] args){
int a , b;
a = 10;
// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
b = (a == 1) ? 20 : 30;
System.out.println( "Value of b is : " + b );
// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
b = (a == 10) ? 20 : 30;
System.out.println( "Value of b is : " + b );
}
}
这里指的是，如果a=10，则实现前者，否则，则实现后者，实现方法是：
b=(a==1)?20:30;
结果：
Value of b is : 30
Value of b is : 20
十五、Java循环、条件、
- for(int x<10;x<20;x+=1){} 、while(x<20)、 for(int x : numbers ){}
- if(){} 、if(){}else{}
- switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
public class Test {
public static void main(String[] args){
//switch语句的使用
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
}
}
//实例
public class Test {
public static void main(String args[]){
//char grade = args[0].charAt(0);
char grade = 'C';
switch(grade)
{
case 'A' :
System.out.println("优秀");
break;
case 'B' :
case 'C' :
System.out.println("良好");
break;
case 'D' :
System.out.println("及格");
break;
case 'F' :
System.out.println("你需要再努力努力");
break;
default :
System.out.println("未知等级");
}
System.out.println("你的等级是 " + grade);
}
}
如果 case 语句块中没有 break 语句时，JVM 并不会顺序输出每一个 case 对应的返回值，而是继续匹配，匹配不成功则返回默认 case。
Java Number & Math 类
Java Math 类
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。
public class Test {
public static void main (String []args)
{
System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));
System.out.println("0度的余弦值：" + Math.cos(0));
System.out.println("60度的正切值：" + Math.tan(Math.PI/3));
System.out.println("1的反正切值： " + Math.atan(1));
System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));
System.out.println(Math.PI);
}
}
90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值： 0.7853981633974483
π/2的角度值：90.0
3.141592653589793
####String 的创建
//
String s1 = "Runoob"; // String 直接创建
String s2 = "Runoob"; // String 直接创建
String s3 = s1; // 相同引用
String s4 = new String("Runoob"); // String 对象创建
String s5 = new String("Runoob"); // String 对象创建
字符串长度
//
public class StringDemo {
public static void main(String args[]) {
String site = "www.runoob.com";
int len = site.length();
System.out.println( "菜鸟教程网址长度 : " + len );
}
}
连接字符串
string1.concat(string2);
"我的名字是 ".concat("Runoob");
"Hello," + " runoob" + "!"
####Java 数组
public class TestArray {
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
System.out.println("总和为： " + total);
}
}
下面的图片描绘了数组 myList。这里 myList 数组里有 10 个 double 元素，它的下标从 0 到 9。
处理数组
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// 查找最大元素
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}
结果
- 1.9
- 2.9
- 3.4
- 3.5
- Total is 11.7
- Max is 3.5
For-Each 循环
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// 初始化 Date 对象
Date date = new Date();
// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
}
}
####使用 SimpleDateFormat 格式化日期
import java.util.*;
import java.text.*;
public class DateDemo1 {
public static void main(String args[]) {
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println("当前时间为: " + ft.format(dNow));
}
}
###Calendar类
//创建一个代表系统当前日期的Calendar对象
public class DateDemo1 {
public static void main(String args[]) {
Calendar c = Calendar.getInstance();//默认是当前日期
//创建一个指定日期的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
}
}
//实例
import java.util.*;
public class GregorianCalendarDemo {
public static void main(String args[]) {
String months[] = {
"Jan", "Feb", "Mar", "Apr",
"May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"};
int year;
// 初始化 Gregorian 日历
// 使用当前时间和日期
// 默认为本地时间和时区
GregorianCalendar gcalendar = new GregorianCalendar();
// 显示当前时间和日期的信息
System.out.print("Date: ");
System.out.print(months[gcalendar.get(Calendar.MONTH)]);
System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
System.out.println(year = gcalendar.get(Calendar.YEAR));
System.out.print("Time: ");
System.out.print(gcalendar.get(Calendar.HOUR) + ":");
System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
System.out.println(gcalendar.get(Calendar.SECOND));
// 测试当前年份是否为闰年
if(gcalendar.isLeapYear(year)) {
System.out.println("当前年份是闰年");
}
else {
System.out.println("当前年份不是闰年");
}
}
}
十六、java正则表达式
1.包的导入
2.类的创建
import java.util.regex.*;
class RegexExample1{
public static void main(String[] args){
String content = "I am noob " +
"from runoob.com.";
String pattern = ".*runoob.*";
boolean isMatch = Pattern.matches(pattern, content);
System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);
}
}
结果：
字符串中是否包含了 ‘runoob’ 子字符串? true
十七、Java 方法
在前面几个章节中我们经常使用到 System.out.println()，那么它是什么呢？
- println() 是一个方法。
- System 是系统类。
- out 是标准输出对象。
这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。
那么什么是方法呢？
Java方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
方法的优点
- 1. 使程序变得更简短而清晰。
- 2. 有利于程序维护。
- 3. 可以提高程序开发的效率。
- 4. 提高了代码的重用性。
方法的写法
十八、Java 流(Stream)、文件(File)和IO
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。
十九、一个线程的生命周期
线程是一个动态执行的过程，它也有一个从产生到死亡的过程。
下图显示了一个线程完整的生命周期。
每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。
Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。
默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。
具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。
创建一个线程
Java 提供了三种创建线程的方法：
通过实现 Runnable 接口；
通过继承 Thread 类本身；
通过 Callable 和 Future 创建线程。
//java创建多线程
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// 让线程睡眠一会
Thread.sleep(50);
}
}catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( "Thread-1");
R1.start();
RunnableDemo R2 = new RunnableDemo( "Thread-2");
R2.start();
}
}
###二十、Java接口（interface）
在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
接口特性
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别
1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
接口的声明
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包
public interface NameOfInterface
{
//任何类型 final, static 字段
//抽象方法
}
接口有以下特性：
接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
接口中的方法都是公有的。
implements
关键字implements是一个类，实现一个接口用的关键字，它是用来实现接口中定义的抽象方法。实现一个接口，必须实现接口中的所有方法。使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）
//实例
//定义Bread接口
public interface Bread{
//定义一个方法吃面包(接口中没有具体的实现方法体)
public void eatBread();
}
//Bread接口的实现类
public class BreadImpl implements Bread{
//实现eatBread方法(接口的实现类中需要有具体的方法体)
public void eatBread(){
System.out.println("吃面包");
}
}
public interface Milk{
//定义一个方法喝牛奶
public void drinkMilk();
}
//Bread接口的实现类
public class MilkImpl implements Milk{
//实现eatBread方法(接口的实现类中需要有具体的方法体)
public void drinkMilk(){
System.out.println("喝牛奶");
}
}
//多重实现
public class Man implements Bread,Milk{
//实现了Bread接口中eatBread方法
public void eatBread(){
System.out.println("吃面包");
}
//实现了Milk接口中drinkMilk方法
public void drinkMilk(){
System.out.println("喝牛奶");
}
}
####关于接口的作用：
接口是软件编程的规范，可以降低耦合性，换句话说，可以让某个模块或功能能够重复利用，这样只要写这功能一次代码就ok了。其他地方要用到的，全部用接口调用来实现
####关键字extends，表示对父类的继承，可以实现父类，也可以调用父类初始化。而且会覆盖父类定义的变量或者函数。在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
###类的继承格式
class 父类 {
}class 子类 extends 父类 {
}
二十一、Java继承
//企鹅类
public class Penguin {
private String name;
private int id;
public Penguin(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
//老鼠类
public class Mouse {
private String name;
private int id;
public Mouse(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
//公共父类
public class Animal {
private String name;
private int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
//继承后的企鹅类以及老鼠类
public class Penguin extends Animal {
public Penguin(String myName, int myid) {
super(myName, myid);
}
}
public class Mouse extends Animal {
public Mouse(String myName, int myid) {
super(myName, myid);
}
}
####继承类型
implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
//举例
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
####super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
//实例
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
输出结果
animal : eat
dog : eat
animal : eat
###二十二、Java重写与重载
###重写(Override)
当需要在子类中调用父类的被重写方法时，要使用 super 关键字。
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
super.move(); // 应用super类的方法
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal b = new Dog(); // Dog 对象
b.move(); //执行 Dog类的方法
}
}
结果
动物可以移动
狗可以跑和走
###重载(Overload)
(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kh6sJHZ2-1635327793815)(https://www.runoob.com/wp-content/uploads/2013/12/20171102-1.png “形象比喻”)]
###二十三、Java多态
多态性是对象多种表现形式的体现。
现实中，比如我们按下 F1 键这个动作：
如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
多态的优点
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性
多态存在的三个必要条件
继承
重写
父类引用指向子类对象：Parent p = new Child();
instanceof
instanceof是Java的一个保留关键字，左边是对象，右边是类，返回类型是Boolean类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。
//多态实例
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
结果
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠
//多态实例：
/* 文件名 : Employee.java */
public class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Employee 构造函数");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck() {
System.out.println("邮寄支票给： " + this.name
+ " " + this.address);
}
public String toString() {
return name + " " + address + " " + number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}
/* 文件名 : Salary.java */
public class Salary extends Employee
{
private double salary; // 全年工资
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Salary 类的 mailCheck 方法 ");
System.out.println("邮寄支票给：" + getName()
+ " ，工资为：" + salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if(newSalary >= 0.0) {
salary = newSalary;
}
}
public double computePay() {
System.out.println("计算工资，付给：" + getName());
return salary/52;
}
}
/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
public static void main(String [] args) {
Salary s = new Salary("员工 A", "北京", 3, 3600.00);
Employee e = new Salary("员工 B", "上海", 2, 2400.00);
System.out.println("使用 Salary 的引用调用 mailCheck -- ");
s.mailCheck();
System.out.println("\n使用 Employee 的引用调用 mailCheck--");
e.mailCheck();
}
}
结果：
Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck --
Salary 类的 mailCheck 方法
邮寄支票给：员工 A ，工资为：3600.0
使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法
邮寄支票给：员工 B ，工资为：2400.0
1258
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
