JAVA面向对象编程知识点
1.java继承：
class 父类 {
}
class 子类 extends 父类 {
}
2.
需要注意的是 Java 不支持多继承，但支持多重继承。
（多继承是指一个类继承多个类的变量和方法；多重继承指的是B继承A，然后C再继承B）
3.继承的特点：
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
4.使用 implements 关键字
可以变相的使java具有多继承的特性：
public class C implements A,B {
}
5.super关键字：
我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
6.final 关键字
声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
final class 类名 {//类体}
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
7.子类是不继承父类的构造器
（构造方法或者构造函数）的，它只是调用（隐式或显式）。
如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
8.重写
是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
例如：
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}
【b属于Animal类型，但是它运行的是Dog类的move方法。】
9.重载(overloading)
是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
例如：
//以下两个参数类型顺序不同
public String test(int a,String s){
System.out.println("test3");
return "returntest3";
}
public String test(String s,int a){
System.out.println("test4");
return "returntest4";
}
10.多态
就是同一个接口，使用不同的实例而执行不同操作。
多态存在的三个必要条件:
继承
重写
父类引用指向子类对象
例如：
public class studentImpl implements Istudent,Iteacher{
@Override
public String getUsername() {
// TODO Auto-generated method stub
return null;
}
public String getTeacher(){
return null;
}
}
public static void main((String[] args){
Iteacher itercher=new StudentImpl();
Istudent istu=new StudentImpl();
}
11.抽象类
除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
在Java语言中使用abstract class来定义抽象类。
12.实现Java封装的步骤
- 修改属性的可见性来限制对属性的访问（一般限制为private）
- 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问.
13.接口（英文：Interface）
，在JAVA编程语言中是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。
接口的声明语法格式如下：
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法，接口内的方法默认为抽象方法。
}
14.抽象类和接口的区别
- 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
- 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
- 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
- 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
15.
不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
package net.java.util;
public class Something{
...
}
那么它的路径应该是 net/java/util/Something.java 这样保存的。
包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
编译所有该包声明的文件，并把他们放在一个用该包名命名的子目录中。
16.import导入包。
17.自定义类型：
引用类型
即自己定义的类或接口。
18.强制类型转换也可以对对象执行：
比如多态，将对象的接口类型进行转换。
19.异常处理
所有的异常类是从 java.lang.Exception 类继承的子类。
java.lang包自动引用。
异常类有两个主要的子类：IOException 类和 RuntimeException 类。
（1）
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
例如：
try
{
// 程序代码
}catch(ExceptionName e1)
{
//Catch 块
}
Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。
（2)多重捕获块：
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}
上面的代码段包含了 3 个 catch块。
如果保护代码中发生异常，异常被抛给第一个 catch 块。
如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。
如果不匹配，它会被传递给第二个 catch 块。
如此，直到异常被捕获或者通过所有的 catch 块。
[异常处理机制主要处理检查性异常，而不是非检查性异常和Error]
20.
如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
例如：
public void deposit(double amount) throws RemoteException，InsufficientFundsException
{
// Method implementation
throw new RemoteException();
}
21.finally关键字
finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
例如：
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}
22.
可以像下面这样定义自己的异常类：
class MyException extends Exception{
}
只继承Exception 类来创建的异常类是检查性异常类。