JAVA面向对象进阶篇

一，类的继承
格式：
class 父类
class 子类 extends 父类{}
在JAVA中一个子类只允许继承一个父类
即只允许多层继承，不允许多重继承
子类不能够直接访问父类中的私有成员，但可以调用父类中的非私有方法
在子类实例化的过程中先调用父类的构造再调用子类的构造方法。

package one;
 class Person{
  public Person(){
   System.out.print("这是父类中的构造方法\n");
  }
  private String name;
  public void setName(String name){
   this.name=name;
  }
  public String getName(){
   return this.name;
  }
 }
 class Student extends Person{
  public Student(){
  //super()   默认这里有super()代表调用父类的无参构造方法
   System.out.print("这是子类中的构造方法");
  }
 }
public class one1 { 
 public static void main(String[] args) {
   Student stu=new Student();
   stu.setName("小红");
   System.out.print("\n"+stu.getName());
 }
}
//运行结果：
这是父类中的构造方法这是子类中的构造方法
小红

二，方法的覆写
被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
三种访问权限的大小关系：private<default<protected<public
（但是要注意，若父类中的方法是private的，而子类将此方法声明为default则不是方法覆写）
在子类的方法中访问父类的方法，则使用super关键字即可，与this()调用构造方法的要求一样语句必须放在子类构造方法的首行。因此this和super是不能同时出现的

class Person{
  private String name;
  public void setName(String name){
   this.name=name;
  }
  public String getName(){
   return this.name;
  }
  private void fun(){
   System.out.print("Person-->中的方法");
  }
  public void print(){
   this.fun();
  }
 }
 class Student extends Person{
  void fun(){
   System.out.print("Student-->子类中的方法");
  }
 }
public class one1 { 
 public static void main(String[] args) {
   Student stu=new Student();
   stu.print();
 }
}

//运行结果：
 Person-->中的方法

方法的覆写并不会改变父类中的方法。

 class Person{
  
   void fun(){
   System.out.print("Person-->中的方法");
  }
 }
 class Student extends Person{
  public void fun(){
   System.out.print("Student-->子类中的方法");
  }
 }
public class one1 { 
 public static void main(String[] args) {
  Person per=new Person();
  per.fun();
  Student stu=new Student();
  stu.fun();
   
 }
}
//运行结果：Person-->中的方法Student-->子类中的方法

三，final关键字
1，使用final声明的类不能有子类
2，使用final声明的方法不能被覆写
3，使用final声明的变量即成为常量，常量不能被修改
四，抽象类
定义格式：
abstract class 抽象类名称{
属性；
访问权限 返回值类型 方法名称（参数）{} //普通方法
访问权限 abstract 返回值类型 方法名称（参数）；//抽象方法
}
在JAVA中有一种类可以专门用来当做父类，它就是抽象类。
不能直接由抽象类创建对象，只能通过抽象类派生出来的新类创建对象，在抽象类中同样存在单继承的局限，即一个子类只能继承一个抽象类。
抽象类的使用规则：
1，包含一个抽象方法的类必须是抽象类
2，抽象类和抽象方法都要使用abstract关键字声明
3，抽象方法只需要声明，不需要实现
4，抽象类必须被子类继承，子类（如果不是抽象方法）必须覆写抽象类中的全部抽象方法。
一个抽象类不能使用final关键字声明
抽象方法不能使用private修饰

五，接口的基本概念
接口可以理解为是一种特殊的类，里面全部是由全局常量和抽象方法所组成。
格式：
interface 接口名称{
全局常量；
抽象方法；
}
== 注意，在接口中的抽象方法必须使用public访问权限。，就算不写public 它默认的也是public的==

与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口
class 子类 implements 接口A，接口B....{}

一个子类同时可以实现多个接口，这样实际上就摆脱了JAVA单继承的局限
一个接口不允许继承抽象类，但一个接口可以继承多个接口
格式：interface 子接口 extends 父接口A，父接口B…{}
六，对象的多态
对象的多态性主要分为两种：
格式：
对象向上转型：父类 父类对象=子类实例
对象向下转型：子类 子类对象=（子类）父类实例
在进行向下转型之前必须先发生向上转型

 class A{
  public void fun1(){
   System.out.print("这是A中的fun1()方法");
  }
 }
 class B extends A{
  public void fun1(){
   System.out.print("这是B中的fun1()方法");
  }
  public void fun3(){
   System.out.print("这是B中的fun3()方法");
  }
 }
public class one1 { 
 public static void main(String[] args) {
   A a=new B();//完成了向上转型
   a.fun1();//一旦发生向上转型之后，调用的方法肯定是被子类覆写过的方法
 }
}
//运行结果：
这是B中的fun1()方法

class A{
  public void fun1(){
   System.out.print("这是A中的fun1()方法");
  }
 }
 class B extends A{
  public void fun1(){
   System.out.print("这是B中的fun1()方法");
  }
  public void fun3(){
   System.out.print("这是B中的fun3()方法");
  }
 }
public class one1 { 
 public static void main(String[] args) {
   A a=new B();//在向下转型之前必须有向上转型
   B b=(B)a;//完成了向下转型
   b.fun1();
   b.fun3();
 }
 }
 //运行结果：
 这是B中的fun1()方法这是B中的fun3()方法