JavaSE基础篇（四）

面向对象基本语法

Java是一种面向对象的语言，在java语言的描述下，万事万物皆对象。
理解面向对象（OOP）：
1，面向对象是相对面向过程而言。
2，面向过程强调的是功能行为，例如C语言是一个面向过程的语言。
3，面向对象将功能封装进对象，强调具备功能的对象。
4，面向对象是基于面向过程的。
理解类和对象：
类是广泛的概念，表示一个具有相同属性和方法的多个对象的集合，是一个有共同性质的群体，而对象，所谓”万物皆对象”，指的是一个
实实在在的东西。
成员变量和局部变量的作用范围：成员变量作用于整个类中，存储于堆内存中，而局部变量作用在函数中或语句中，存储在栈内存中。
构造函数的书写规范：
1，函数名必须和类名一样。
2，不用定义返回值。
3，不可以写return语句。
作用： 当分析事物时，该事物具备一些特性或者行为，那么将这些内容定义在构造函数中，给对象进行初始化。
注意:
1，一个类中没有定义构造函数时，系统会默认给该类加一个空参数的构造函数。
2，当在类中自定义了构造函数后，默认的构造函数就没有了。
3，自定义的多个构造函数是以重载的方式存在的。
4，一个对象的建立，构造函数只运行一次，而一般方法可以被对象调用多次。

构造代码块的作用：给对象进行初始化。对象一建立就运行，优先于构造函数执行。
与构造函数的区别：构造代码块是给所有对象统一初始化，而构造函数是给对应的对象初始化。
this关键字代表本类对象。
super代表的是父类对象的引用。
static关键字：用于修饰成员（成员函数和成员变量）
被修饰后的成员具备以下特点：
1，随着类的加载而加载，并随着类的消失而消失，生命周期最长。
2，优先于对象存在
3，被所有对象所共享
4，可知直接被类名调用。
5，存储与方法区中，成员变量随着对象的建立存在于堆内存中。
6, 成员变量随着对象的消失而消失。
静态代码块：
1，随着类的加载而执行。
2，作用是用于给类进行初始化，也就是类一进内存还没有建立对象时就需要对类做一些初始化动作。
static使用注意：
1，静态方法只能访问静态成员
2，静态方法中不可以写this，super关键字
3，main函数必须是静态方法。

继承（extends）:
继承是java不可或缺的一部分，在java中任何类都继承了java的标准根源类Object。
继承的优势：
1,提高了代码复用性。
2，让类与类之间产生了关系，有了这个关系，才有了多态的特性
注意：千万不要为了获取其他类的功能和简化代码使用继承，必须是类与类之间有所属关系才可以继承。所属关系为is a。
java语言中，java只继承单继承，不支持多继承因为多继承会带来安全隐患，当一个类继承多个父类是，如果父类中有相同的函数，子类在调用函数时不知道该调用哪一个。
但是java支持多层继承，也就是一个继承体系。
想要使用体系，先查阅体系父类的描述，因为体系父类描述的是体系的共性功能。通过了解共性功能，就可知道该体系的基本功能。
在具体调用时，要创建子类对象。原因：
1，父类可能不可以创建对象。
2，创建子类对象可以获得更多的功能，包括共有的和特有的。

当子类继承父类时，沿袭了父类的功能到子类中。而且子类可以重新定义父类的功能，即进行功能的覆盖。
功能覆盖规则：
1，子类覆盖父类时，必须保证子类权限大于等于父类权限才可以覆盖。
2，静态只能覆盖静态。
子父类中的构造函数：在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数第一行有一条隐式的super()语句。
子类必须访问父类中的构造函数的原因：
以为父类中的数据子类可以直接获取，所以子类对象在建立的时候，需要先查看父类是如何对这些数据进行初始化的，
故子类在进行对象初始化的时候，要先访问一下父类中的构造函数
如果要访问父类中制定的构造函数，可以在子类手动定义super语句的方式来访问。
注意： super语句一定要定义在子类构造函数的第一行

final关键字：
1，final可以修饰类，方法，变量。
2，final修饰的类不可以被继承 。（为了避免继承后被子类复写功能）
3，final修饰的方法不可以被覆盖。
4，final修饰的变量只是一个常量，只能被赋值一次，既可以修饰成员变量，又可以修饰局部变量。
注意：内部类只能访问被final修饰的布局变量。

抽象类（abstract）：
当多个类中出现相同功能，但是功能的主体不同这时可以进行向上抽取，值抽取功能定义，而不抽取功能主体。
定义抽象类的语法:
1，抽象方法一定在抽象类中
2，抽象方法和抽象类都必须被abstract关键字修饰
3，抽象类不可以用new创建对象，因为调用抽象方法没意义
4，抽象类中的方法要被使用，必须由子类复写所有的功能，建立子类对象对用，如果子类只复写了部分功能，那这个子类仍是抽象类。
抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西,通过抽象方法来表示，并交给子类来实现。抽象类比一般类多了一个子类。
注意： 抽象类不可以被实例化。抽象类可以不定义抽象方法，这样做仅仅是不让该类建立对象。
用抽象类来获得一段程序运行的时间的例子：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
class GetTime
{
public void getTime()
{
long start = System..currentTimeMillis();
runCode();
long end = System.currentTimeMills();
System.out.println(“spend time is : “+(end -start));
}

//在这里我们不知道成具体是什么，故将其抽象，叫给继承GetTime的子类区实现。
public abstract void runCode();
}

class SubTime extends GetTime
{
public void runCode()
{
for(int i=0; i<100; i++)
{
System.out.println(i);
}
}
}

public class Test
{
public static void main(String[] args)
{
SubTime sub = new SubTime();
sub.getTime();
}
}

上面例子实际用到了模板设计模式。
模板方法设计模式：
在定义功能时，功能一部分是确定的，而另一部分是不确定的，而确定的部分在使用不确定
的部分，那么这是就将不确定的部分暴露出去，有该类的子类区完成

接口（interface）：
初期理解，可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class用来定义类，interface用来定义接口。
接口的特点：
1，接口是对外暴露的规则
2，接口是程序的功能扩展
3，接口可以用来多实现
4，类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
5，接口与接口之间可以有继承关系
格式特点
1，接口中常见的定义： 常量，抽象方法
2，常量： 用 public static final 修饰
方法： 用 public abstract 修饰

注意: 接口的成员都是public的，接口是不可以创建对象的，因为有抽象方法。子类对接口中的方法全部覆盖后，子类才可以被实例化，否则子类是一个抽象类。
接口可以被类多实现，这也是对多继承不支持的转换形式。
举例：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
abstract class Student
{
public abstract void study();

public void sleep()
{
System.out.println(“sleep”);
}

}

interface Smoking
{
public void smoke();
}

class ZhangSan extends Student implements Smoking
{
public void study()
{
System.err.println(“zhangsan study at university”);
}

@Override
public void smoke()
{
System.out.println(“zhangsan smoke”);
}
}

class Lisi extends Student
{
public void study()
{
System.err.println(“lisi study at university”);
}

}

public class test
{
public static void main(String[] args)
{
ZhangSan a = new ZhangSan();
Lisi l = new Lisi();
a.study();
a.smoke();
l.study();
}
}

因为不是每个学生都有smoke的功能，故在Student类中只抽取所有学生都具备的功能：学习和睡觉。
让会抽烟的学生去实现Smoking接口，不会抽烟的学生则不实现Smoking接口。

多态（polymorphic）：
可以理解为事物存在的多种体现形态。
1，多态的体现：父类的引用也指向了自己子类对象。父类的引用也可以接受自己的子类对象
2，多态的前提：必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提： 存在覆盖
3，多态的好处：多态的好处大大的提高了程序的扩展性
4，多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类的成员。
例子：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
class Animal
{
public void eat()
{
System.out.println(“eat food”);
}
}

class Cat extends Animal
{
public void eat()
{
System.out.println(“eat fish”);
}

public void catchMouse()
{
System.out.println(“Catch Mouse”);
}
}

class Dog extends Animal
{
public void eat()
{
System.out.println(“eat bone”);
}

public void bark()
{
System.out.println(“bark…..”);
}
}

public class test
{
public static void main(String[] args)
{
Animal cat = new Cat();
Animal dog = new Dog();
cat.eat();
dog.eat();
((Cat)cat).catchMouse();
}
}

结果输出:
eat fish
eat bone
Catch Mouse
上面的例子中，因为cat是Animal的引用类型，所以cat只能调用eat这个方法，而不能调用catchMouse方法。
要想调用catchMouse函数，必须强制将cat转换为Cat类型。注意：绝对不能将（new Animal()）强制转换成
Cat或者Dog类型的对象，原因其实很好理解，猫一定是一个动物，但动物不一定是猫！！
多态中成员函数的特点：
1，在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过。
2，在运行时期，参阅对象所属的类中是否有调用的方法。

内部类（inner-class）：
内部类访问特点：
1，内部类可以直接访问外部类中的成员，包括私有成员，之所以可以直接访问外部类中的成员，是因为内部类持有格式：外部类.this.成员
2，而外部类要访问内部类的成员必须要建立内部类的对象了一个外部类引用。
访问格式：
当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象
注意： 当内部类中的定义了静态成员，该内部类必须是静态的。当外部类中的静态方法访问内部类时，内部类也必须是静态的。
当描述事物时。事物内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。
从内部类中访问局部变量，需要将局部变量声明为最终类型

匿名内部类：
1，匿名内部类其实就是内部类的简写格式
2，定义匿名内部类的前提：内部类必须是继承一个类或者实现一个接口
3，匿名内部内的格式：new父类或者接口(){内容}；

异常（Exception）：
在java中可以使用两种方法来处理异常：
1，在发生异常的地方直接处理。
2，将异常抛出，让调用者来处理异常。
java提供了丰富的异常类，他们都是java.lang.Throwable的子孙类。
异常体系：
Throwable
|–Error
|–Exception
|–RuntimeException
异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。
java将异常划分为三种：
1，检查型异常（Exception）： 描述了正确程序中所发生的问题，这些问题一般情况下是因为外在环境的条件不满足而引起的，如用户错误及IO异常
2，运行期异常（RuntimeException）：通常意味着程序存在bug，一般需要通过更改程序来避免。
3，错误（Error）：错误可能来源于一个程序bug，但一般情况下更可能来源于环境的问题，如内存耗尽问题。
其中运行期异常类是检查型异常类的子类。
异常的处理：
java提供了特有的语句进行处理，
try
{
需要别检测的代码。
}
catch ()
{
处理异常的代码（处理方式）
}
finally
{
一定会执行的语句。
}
异常声明throws：在功能上通过throws关键字声明该功能有可能会出现的问题。
如果函数声明了异常，调用者需要进行处理，处理方式可以throws也可以trycatch。
当函数内容有thorw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败
注意：RuntimeException除外。也就是时候如果函数内容有抛出RuntimeException异常对象，函数上可以不用声明。
举例：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
class Demo
{
public double div(int a, int b)
{
if(b<=0)
throw new RuntimeException(“除数小于等于零！！！”);
return a/b;
}
}

public class test
{
public static void main(String[] args)
{
Demo demo = new Demo1();
demo.div(1, 0);
}
}

div函数和main函数都没有声明异常，main函数中也没有用try处理异常，但编译能通过，这就是运行时异常的特点，程序会在抛出运行时异常的地方停止运行。
throws和throw的区别：
1,throws使用在函数上。
2，throw使用在函数内。
3，throws后面可以跟多个异常类，throw抛出的是异常类的对象。
处理异常的注意事项：
1，声明异常时，建议声明更为具体的异常。
2，对方声明几个异常，就对应有几个catch块，不要定义多余的catch块，如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
注意：建立catch处理时，catch中一定要定义具体处理方式，不要简单定义一句： e.printStackTrace()。也不要简单的就写一条输出语句。
自定义异常：因为项目中会出现特有的问题，而这些问题并未被java所描述并封装成对象，此时要自定义异常封装。
自定义异常类继承Exception或者RuntimeException的原因：
1，为了让该自定义类具备可抛性
2，让该类具备操作异常的共性方法。
异常处理语句格式：
第一种：
try
{

}
catch ()
{
}

第二种：
try
{

}
catch ()
{
}
finally
{
}

第三种：
try
{
throw 异常对象
}
finally
{
出现错也必须要执行的代码，入关闭资源
}

记住： catch是用于处理异常，如果没有catch就代表异常没有被处理过。
异常-覆盖时的异常特点：
1,子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者改异常的子类。
2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3，如果父类后者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，必须进行try处理，绝对不能抛出异常。
finally块只有在一种情况下不会执行，即当执行到System.exit(0)的时候。
java异常处理机制的好处在于将问题进行封装，使正常流程代码和问题处理代码想分离，方便于阅读。