JAVA面向对象01

1.【理解】什么是继承

2.【掌握】继承的使用

3.【理解】继承中的成员的特点

4.【理解】super和this的使用

5.【理解】什么是抽象类

6.【掌握】抽象的使用

继承

---

继承的概述与概念

---

概述：在面向对象里边，继承是对上一章的类，进一步抽象的过程。蛋多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，这个类就是父类，那么多个子类则无需再定义这些属性和行为，只要继承那么一个类（父类）即可。

        其中多个类可以成为子类，单独那么一个类称为父类、超类（superclass）或者基类。

概念：继承就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类的非私有的属性和行为。

继承的特点

---

•   子类自动拥有父类非私有的成员（成员变量、成员方法）
•   子类也可以拥有自己的成员

继承的好处

---

• 提高代码的复用性，降低重复代码；
• 由于有了继承，类与类之间产生了关系，时多态的基础

继承的格式

---

        通过extends关键字，可以声明一个子类继承另一个父类，定义格式如下：

格式：

class 父类{ 。。 }

class 子类 extends 父类{。。。}

例子：

//父类
publi class Person{
    public void eat(){
    
        sout("吃饭");
    }
    public void sleep(){

        sout("睡觉");
    }
}
//子类

public class Student extends Person {}

public class Teacher extends Person{ }

//测试类
public class PersonTest{
       //main 方法
     public static void main(String[] args) { 
        //学生类
        Student s = new Student();
        s.eat();
        s.sleep();

        //教师类
         Teacher t = new Teacher ();
        t.eat();
        t.sleep();
    }
}

继承中成员访问的特点

---

子类访问父类非成员

---

public class Father{

    //定义私有成员变量
    private int num = 10;
    public int num2 = 20;

    //私有的成员方法
    private void mothod（）{
    
        sout(num);
        sout(num2);
    }

    public void show(){

        sout(num);
        sout(num2);
    }

}

public class Son extends Father{

    //子类也可以有自己的东西
    public void function(){

        //子类不能访问父类中的私有成员变量
        //System.out.println(num);


        System.out.println(num2);
    }
}

public class SonTest{
    
    public static void main(String[] args){

        Son s = new Son();
        //s.num = 200;子类不能访问父类中的私有的成员变量

        s.num2 = 100;

        //s.mothod();//子类不能访问父类中的私有成员方法

        s.function();//可以访问自己的方法
        s.show();
    }
}

成员变量

---

成员变量不重名

---

        如果子类父类中出现不重名的成员变量，这时的访问时没有影响的。

//父类
public class Father {
    int num = 10;
}

//子类
public class Son extends Father {
    //子类成员变量
    int num2 = 20;
    
    //子类成员方法
    public void function(){
        // 访问父类中的num，
        System.out.println("Fu num="+num); //10    

        // 访问子类中的num2
        System.out.println("Zi num2="+num2); // 20
    }
}

//测试类
public class SonTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.function();
    }
}

 成员变量重名

---

        如果子类父类中出现成员变量，这时的访问是有影响的。

        当子类父类出现相同的成员变量时，在子类中需要访问父类中的非私有变量时，需要使用super关键字，修饰父类成员变量，用法类似于this。

//父类
public class Father {
    int num = 10;
}

//子类
public class Son extends Father {
    int num = 20;
    //子类成员方法
    public void function(){
        //如果子类成员变量的名与父类成中变量名一样，就近原则
        System.out.println("num="+num); //20    
    }
}

//测试
public class SonTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.function();

    }
}

使用格式

---

super.父类成员变量

public class Son extends Father {

    int num = 20;

    //子类成员方法
    public void function(){
        //如果子类成员变量的名与父类成中变量名一样，就近原则
        // System.out.println("Fu num="+num); //20    

        //我就想访问父类中的成员变量，怎么办？  用super
        System.out.println(super.num);//此时访问的就是父类的成员变量 10

    }
}

• 注意：父类当中的成员变量是非私有时，子类可以直接进行访问。当父类中的成员变量为私有时，子类不能直接进行访问，通常可以在父类中提供set、get方法使其子类进行调用。

成员方法

---

成员方法不重名

---

        如果子父类中出现不重名的成员方法，这时调用是不受任何影响。

//父类
public class Father {
    public void show(){
        System.out.println("我是父类Father");
    }
}

//子类
public class Son extends Father {
    public void show2(){
        System.out.println("我是子类Father");
    }
}

//测试
public class SonTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.show();//调用父类方法

        s.show2();//调用子类方法
    }
}

方法重写（override）

---

        如果子类与父类中出现重名的成员方法，这时访问的是一种特殊情况，叫做重写（override）。

• 什么是方法重写

  ---

方法重写：子类中出现了与父类相同的方法时（返回值类型  方法名、参数列表都相同），会出现覆盖效果，也成为重写或者复写。生命不变，重新实现。

• 代码演示：

  ---

//父类
public class Father {
    public void show(){
        System.out.println("我是父类Father");
    }

    public void method(){
        System.out.println("我是父类method");
    }
}
//子类
public class Son extends Father {
    public void show2(){
        System.out.println("我是子类Father");
    }

    public void method(){
        System.out.println("我是子x`类method");
    }
}

//测试
public class SonTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.show();//调用父类方法
        s.show2();//调用子类方法
        System.out.println("===================");
		
        //方法重写：子类中出现了与父类中的一模一样的方法
        //子类重写了父类的方法
        s.method();
    }
}

方法重写的应用场景

        子类可以根据自身需求，定义特定于自己的行为。即沿袭了父类的功能名称，又能根据子类的需求重新实现父类的方法，从而进行扩展增强。

• 代码演示：

class Phone {
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示号码");    }
}

//智能手机类
class NewPhone extends Phone {
    //重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能   
    public void showNum(){        
        //调用父类已经存在的功能使用super
        super.showNum();
        
        //增加自己特有显示姓名和图片功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}

public class ExtendsDemo06 {
    public static void main(String[] args) {
        // 创建子类对象
        NewPhone np = new NewPhone()；

        // 调用父类继承而来的方法
        np.call();

        // 调用子类重写的方法
        np.showNum();

    }
}

方法重写的注意事项：

        1.子类方法重写父类方法，必须保证权限大于等于父类权限，最好修饰权限一样。

        2.子类方法重写父类方法，返回值类型、方法名和参数列表都要一摸一样。

构造方法执行特点

• 描述

        1.构造方法的名字是与类名一致，所有子类是无法继承父类构造方法的。

        2.构造方法的作用是初始化成员变量的。所有子类的初始化过程中，必须先执行父类的初始化动作。子类的无参构造方法中默认有一个super(),表示调用的是父类的构造方法，父类成员变量初始化后，才可以给予子类使用。

注意：在IEDA中构造方法的快捷方式Alt+ins；

//父类
public class Father {
    private int num;
    //父类的构造方法
    public Father(){
        System.out.println("父类的构造方法");
    }
    public Father(int num) {
        this.num = num;
    }
    public void show1(){
        System.out.println(num);
    }
}

//子类
public class Son extends Father {
    //子类无参构造方法
    public Son(){
        // 子类构造方法中的第一行默认有 super() ,给父类进行初始化的
        // 作用：因为继承必须先调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。
        super();
        System.out.println("子类的构造方法");
    }
    //子类有参构造方法
    public Son(int num2) {
        super(34);
        this.num2 = num2;
    }

    public void show2(){
        System.out.println(num2);
    }    
}

//测试
public class Test {
    public static void main(String[] args) {
        //在每次创建子类对象时，都会先初始化父类构造方法，再创建其子类对象本身。
        Son s = new Son();
        Son s = new Son();//每一次实例子类对象，都会先访问父类的无参构造  （这里两次）
        
        //访问有参构造
        Son s = new Son(2000);
        s.show1();
        s.show2();
    }
}

访问构造方法的注意事项

• 在子类构造方法当中的第一行默认有super(),给父类进行初始化的
• 在子类构造方法中可以手动调用父类其他重载的构造方法
• 格式：super (参数列表):
• super 是写在子类的构造方法的第一行

• 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

• super()和this()都必须是在构造方法的第一行，所以不能同时出现。

注意： 

        

【super.父类成员方法】，表示调用父类的成员方法

【super.父类成员变量名】，表示调用父类的成员变量

【super()】,表示访问父类中的无参构造

【super( 88 )】, 表示访问父类中的有参构造

 super和this

 super和this的含义

•  super：前提：继承关系。代表父类的存储空间标识（可以理解为父亲的引用）
• this：代表对当前对象的引用，（谁调用就代表谁）

super和this的用法

• 访问成员

this.成员变量   -------本类的

this.成员方法   -------本类的

          

super.成员变量   -------父类的

super.成员方法   -------父类的

继承的特点

---

/*
	Java中继承的特点：
		A:Java只支持单继承，不支持多继承。
			
		B:Java支持多层继承(继承体系),间接继承
*/

class Father(){}
class Mother(){}

class son extends Father(){} // 正确
class son2 extends Father , Mother {} // 不正确

• Java只支持单继承，不支持多继承

//一个类只能有一个父类，不可以有多个父类。
class C extends A{}     //ok
class C extends A，B...  //error

• Java支持多层继承（继承体系）

class A{}

class B extends A{}
class C extends B{}

• 子类和父类是一种相对的概念

                一个父类可以有很多个子类。