Java面向对象

类和对象

目前主流两大开发方法：面向过程和面向对象。面向过程也称为结构化开发

类，就是具有一些相同属性和行为。有些对象的属性和行为是相同的，可以将其抽象为一个类。

类是从对象中抽取出来的，对象是类的一个实例。

面向对象的三大特征：封装、继承和多态。

类的定义：

[Modifier] class className

{

//[field,method]

}

类名定义规范：当有一个单词时首字母大写，合成词的时候第二个单词首字母大写。

创建类的对象：ClassName name = new ClassName();

定义类和对象：

<span style="font-size:18px;">public class Person {public String name;public String gender;public int age;public void eat(String name){//方法具体实现}}</span>

<span style="font-size:18px;">public class PersonTest {public static void main(String[] args) {Person p = new Person();p.name = "小明";p.gender = "男";p.age = 18;p.eat("小刚");}}</span>

注意：创建对象使用new关键字，调用属性和方法使用”.“。

类的属性又称：字段、成员变量。

类的行为又称：方法、成员方法。

类的属性和行为统称为类成员。

成员方法是用来描述行为或功能的。

方法重载

方法同名，参数项不同，与访问修饰符、返回值无关。

例如：

<span style="font-size:18px;"><span style="white-space:pre"></span>public void work(){System.out.println("正在工作中………");}public void work(String name){System.out.println(name+"正在工作中…………");}</span>

当局部变量与成员变量重名时，方法直接调用的是局部变量，当方法要调用成员变量时，通过关键字this.变量名来调用。

例如：

<span style="font-size:18px;">public class Person {public String name;public void work(String name){System.out.println(this.name+"在和"+name+"一起完成一项任务！");}}</span>

构造方法

1、构造方法必须的名字必须与类名相同。

2、不能指定返回值类型。

例如：

<span style="font-size:18px;">public class Person {public String name;public int age;public Person(String name,int age){this.name = name;this.age = age;}}</span>

构造方法是在创建该类的对象是进行使用的。

构造方法也可以重载，重载方法与普通方法一致。

封装

OOP(Object Oriented Programming)面向对象程序设计三大特性：封装、继承和多态。

封装反应了事物的相对独立性。

封装的作用：使对象以外的部分不能随意更改对象的属性，从而避免了外部错误对此对象的影响。

面向对象编程提倡对象之间实现松耦合关系（松耦合就是指尽量减少对象之间的关联性）

封装就是将属性私有化，通过公有方法来访问私有属性，这样的一个类就实现了封装特性的类。

继承

继承就是能够让一个类直接使用另外一个类的属性和方法的途径，并且这个类可以有自己的属性和方法。

继承的语法：

<span style="font-size:18px;">修饰符 class subClass extends SuperClass{}</span>

例如：

<span style="font-size:18px;">public class Student extends Person{}</span>

java只支持单继承，即每个类只能有一个直接父类。

子类无法继承父类的构造方法。

子类在实例化时，会首先执行其父类的构造有参构造方法，然后才执行子类的构造方法。

子类从父类中继承的东西：

1、继承public和protected修饰的属性和方法，不论父类和子类是否在一个包下。

2、继承默认权限修饰符的属性和方法，但子类和父类必须在同一个包下。

注意：

1、子类无法继承private修饰的属性和方法。

2、子类无法继承父类的构造方法。

方法的重写（重载）

子类中依据需求对从父类中继承的方法进行重写。

方法重写的要求：

1、必须要有相同的方法名，比如：父类方法名叫做printDetail()子类的方法名也要叫做printDetail()

2、具有相同的参数列表，比如父类中没有参数，子类中也没有参数。

3、返回值类型必须相同或者是其子类。

4、不能缩小被重写方法的访问权限。

super关键字

该关键字必须出现在子类中（子类的构造方法和方法中），不能出现在其他位置。

super是用以访问父类的成员，例如父类的属性、方法、构造方法等。super在访问权限上也有限制，我们无法通过super访问被private修饰的成员。

继承条件下的构造方法遵循以下几点规则：

规则一：如果子类的构造方法中没有通过super显式调用有参构造方法，也没用通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。

规则二：如果子类的构造方法中通过super显式调用父类相应的构造方法，那就不执行父类无参构造方法。

规则三：如果子类构造方法中通过this显式调用自身其他的构造方法，在相应构造方法中应用以上两条。

多态

多态是指在同一个引用对象，使用不同的实例而执行不同的操作。

抽象类是高度抽象提取公共的部分，只声明方法的存在，而不去具体实现它的类，是一个概念性的描述，具体的实现方法由继承他的子类决定，抽象类的定义是为了子类继承的，继承后可以实例化成具体对象。抽象类是不能用new关键字实例化的。

抽象类的定义语法：在class关键字之前加一个abstract关键字，抽象方法即在返回值前加上abstract关键字，不必要写{}以及方法体，由分号结束，例如：

public abstract class Pet {private String name;private int age;abstract void eat();}

注意：

1、抽象类不能被实例化。

2、子类如果不是抽象类，则必须重写抽象类中的全部抽象方法。

3、abstract修饰符不能和final修饰符一起使用。

4、abstract修饰的抽象方法没有方法体。

5、private关键字不能修饰抽象方法。

instanceof运算符语法：<引用变量> instanceof <类名/接口名>

用于判断某个实例是输入某个对象。

接口是从多个类中抽取出来的规范，体现的是规范和实现分离原则。同时有效的解决了java单继承方面的缺陷。抽象类是一个不能被实例化的类，它只能具有抽象方法。

接口使用interface定义，具体语法为：

public interface 接口名称{

抽象方法;

}

注意：

1、接口只能拥有抽象方法。
2、定义接口的时候不在使用class关键字。

抽象类与接口的区别：

1、抽象类除了可以拥有抽象方法外还可以拥有普通方法。

2、抽象类使用abstract声明，接口使用interface声明。

3、抽象类的抽象方法使用abstract修饰，而接口中只能有抽象方法，所以不必使用abstract关键字修饰。

4、抽象类可以通过继承实现，即通过extends关键字，接口的实现可以通过关键字implements来实现。

5、抽象类中抽象方法访问修饰符不能为private，接口中的抽象方法访问修饰符必须是public。

相同点：

1、都不能被实例化。

2、继承了抽象类的子类或实现了接口的类必须重写抽象类或接口中所有的抽象方法。

异常

异常是程序程序运行过程中发生的错误现象，他不是由程序的语法错误导致的，而是由一些偶然的或意外存在的原因导致的。

Throwable是所有异常类的父类，他继承自Object。Throwable下面有两个直接子类，一个是Exception，一个是Error（由jvm抛出的严重错误）。

在Exception这个分支中异常有两个重要分支，一个是运行时异常RuntimeException，一个是已检查异常CheckException，其值RuntimeException是一个具体的异常类型，也是就是说java中有这个类型。

常见的异常类型如下：

1、ArrayIndexOutofBoundsException数组越界异常。

2、NullpointerException空指针异常，也就是说我们使用的引用没有指向任何一个对象。另外数组没有初始化也会引发该异常。

3、ClassNotFountException类找不到异常，表示我们试图使用的类型不存在。

4、NumberFormatException数字格式化异常，当我们想把一个非数字格式的字符串转换为数字时会出现此错误。

5、InputMismatchException输入类型不匹配异常，表示用户给出的类型和系统所需要的类型不一样。

上述异常均可以使用try-catch语句进行处理，try块用了包裹会产生异常的代码，catch块用来处理try中发生的异常。

try-catch-finally语句，finally块的作用就是无论try块中是否有异常发生，也无论catch块中是否捕捉这些异常，finally款至少要执行一次。
java虚拟机不允许将父类的异常类型放在子类前面，这样将不能通过编译。

throws的语法是在方法声明之后，大括号之前，表示该方法将会抛出某些类型的异常。

例如：

<span style="font-size:18px;">public static void ExceptionDemo throws Exception{<span style="white-space:pre"></span>//方法体}</span>

throw关键字语法throw new Exception() 或throw new Exception(String msg);

它表示程序会主动抛出某个类型异常，抛出的位置在方法体内。

使用throw主动抛出异常和throws抛出异常的区别：

1、作用不同，throw用于程序员自行产生并抛出异常，使用throws是为了让方法调用者在执行时可能引发的异常。

2、使用的位置不同，throw位于方法体内部，可以作为单独语句使用；throws必须位于参数列表后面，不能单独使用。

3、内容不同：throw抛出一个异常对象，且只有一个；throws后面跟异常类，并且可以跟多个异常类。

自定义异常

1、继承Throwable

2、继承Exception

3、继承RuntimeException

一般选择继承Exception或者RuntimeException，如果不要求调用者抛出，那么一般继承RuntimeException。

例如：

public class FuShuArrayIndex extends Exception {public FuShuArrayIndex(){}public FuShuArrayIndex(String s){super(s);}}

public  class ExceptionDemo {public static int  method(int[] arr ,int index) throws FuShuArrayIndex{if(index>=arr.length)throw new ArrayIndexOutOfBoundsException("数组越界");if(index<0)throw new FuShuArrayIndex("数组下标不能为负！");return arr[index];}public static void main(String[] args) throws FuShuArrayIndex{int arr[] = new int[3];ExceptionDemo d = new ExceptionDemo();int n = d.method(arr, -3);System.out.println(n); }}