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封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private）
2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问.

13.接口（英文：Interface）

，在JAVA编程语言中是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。
接口的声明语法格式如下：

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法，接口内的方法默认为抽象方法。
}

14.抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

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 类来创建的异常类是检查性异常类。