第三章：面向对象（3）

学习目标：

掌握面向对象的相关知识

---

学习内容：

提示：这里可以添加要学的内容
例如：
1、 继承
2、 抽象类
3、 多态
4、 final关键字
4、 接口

---

学习时间：

2021年5月4日 2021年5月5日

---

学习产出：

1、 技术笔记 1 遍 2、CSDN 技术博客 1 篇

继承

继承：继承是面向对象程序设计不可缺少的设计思想，是实现代码可重用的根基，是提高代码可扩展性的主要途径

继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力

​ 1.在Java中使用extends关键字来表示继承关系

​ 当一个类没有显示的继承其他类的时候,此时这个类默认继承Object

​ Object类是java中所有类的基类(父类 超类)

public class Animal extends Object

​ 2.Java不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个 直接父类。

​ 3.继承之后子类可以调用父类的所有非私有属性和非私有方法

​

继承的传递性

C类从B类继承,B类又从A类继承

那么C类就具有B类和A类的所有非私有属性和非私有方法

继承中的构造方法

子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法

可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法

如果用super,必须写在构造方法的第一句

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

设计Dog类 狗是动物 继承Animal 拥有父类中行为属性(非私有的)

public class Dog extends Animal{

         //无参构造
         public Dog(){
          super();//调用父类的无参构造方法
          System.out.println("Dog无参构造");
        }
        //有参构造
        public Dog(String type){
             super();
             this.type=type;
            System.out.println("Dog有参构造");
        }

        public  void play(){
              System.out.println(super.getName()+"狗会玩");
        }
 }

​

super关键字用途

super关键字代表父类的引用，在程序中主要的用途

• 在子类构造方法中要调用父类的构造方法，

​ 需要注意：super语句只能出现在子类构造方法体的第一行。

• 用“super.成员变量名”来引用父类成员变量

• 用“super.方法名（参数列表）”的方式访问父类的方法。

方法的重写

应用场景 :

​ 当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)

在子类中可以根据需要对从基类中继承来的方法进行重写。

方法重写规则

​ • 方法名相同、参数列表相同；

​ • 返回值类型相同；

​ • 访问权限不能小于父类权限;

注意：构造方法,静态方法不能重写,成员变量不存在重写

//构造方法,静态方法不能被重写,  属性也不存在重写,
        //当父类中实现方式(代码) 不能满足子类中的需求,可以在子类中将父类中的方法重写(方法覆盖 覆写)
        @Override//java中的注解标签  说明 此方法是从父类中重写过来的  在编译期间就会对语法进行校验
        void eat() {
            System.out.println("ssssss");//子类自己的实现方式
            //super.eat();//调用父类的实现
            super.sleep();
            System.out.println("ssssss");
        }

抽象类

如果一个类中没有包含足够的信息(抽象方法)来描绘一个具体的对象，这样的类就是抽象 类。

抽象类中可以没有抽象方法,有抽象方法必定是抽象类。

一般用在体系结构的顶层用来进行功能的定义声明。

public abstract class Animal {

     int num;

     /*
       抽象类可以拥有构造方法,但是不能创建对象
      */
     public Animal(){
         System.out.println("Animal无参构造");
     }

    /*
    *抽象方法:只有方法声明, 没有方法体,也就是没有具体的实现
    */
    public abstract void eat();//在比较顶级的类中就可以定义一个方法即可

     public void sleeep(){
         System.out.println("动物睡觉");
     }
}

一个类如果继承了抽象类 要么重写抽象类中所有的抽象方法 要么将该类也定义为抽象类

//public abstract class Dog extends Animal {
public  class Dog extends Animal {

    public  Dog(){
        super();
    }

    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一 样。否则，该类也必须声明为抽象类。

多态

多态：同一种事物，在不同时刻表现不同的状态

多态存在的三个必要条件

​ ● 要有继承（包括接口的实现）(前提条件)

​ ● 要有重写(前提条件)

​ ● 父类引用指向子类对象

​ 当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class Animal{
……
}
class Cat extends Animal{
…… 
}
class Dog extends Animal {
…… 
}
Animal x = new Cat() //Animal 的引用指向Cat的对象

多态环境下对成员方法的调用

Animal d = new Dog();
         /*
           多态访问类中的成员方法,编译期间调用的是父类中的方法,运行时执行子类中的方法
               编译看左边   运行看有边
          */
       d.eat();
       d.sleep();//对于静态方法编译和运行都看左边

多态环境下对成员变量的调用

System.out.println(d.num);//对于成员变量编译和运行都看左边

                d = new Cat();
                d.eat();

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

向上转型

class Animal{
    void eat(){ }
}
class Cat extends Animal{
    void look() {
        System.out.println("看家"); 
    } 
}
……… 
Animal x=new Cat() //向上造型，Cat对象提升到Animal对象
x.eat() //只能使用父类中的方法 
x.look() //报错！不能使用子类中的方法

向上转型的作用是：提高程序的扩展性。

向下转型

class Animal{
    void eat(){ }
}
class Cat extends Animal{
    void look() {
        System.out.println("看家"); 
    } 
}
……… 
Animal x=new Cat() Cat m=(Cat)x; //向下转型
m.eat() ;
m.look();//子父类中的方法都可以使用

向下转型的作用是：为了使用子类中的特有方法。

final关键字

final 修饰类,属性(成员变量–>常量),方法

修饰类:不能被其他类继承修饰属性;

public final class FinlDemo

修饰后的属性使用前必须赋值,赋值值不能改变修饰方法;

static final int PI = 3;//直接为常量赋值,建议使用static修饰,这样在内存中就只有一份,所有对象共享
        final int num;//不用static修饰,不需要赋初值,每个对象中都会包含一个常量,在构造方法中初始化


       public FinlDemo(int n) {
            num = n;
       }

修饰的方法不能被重写

//修饰方法参数,当调用时传入值后,值不能改变
public final static void  test(final int a){

}

接口

一个类实现接口

要么将此类声明为抽象类

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

  /*
   接口可以继承多个接口
  */
public interface MyInerface extends InterfaceA,InterfaceB{

    //接口中声明的属性默认为 public static final 的；
    //public  static  final    int num  =10;
       int NUM  =10;//静态常量

    //接口中的方法默认为 public abstract 的
    //public abstract void eat();
      void eat();//定义方法(定义功能)
      void sleep();

     /*
      通过子类调用, 默认方法子类可以重写,也可以不重写
      */
     default void test(){
          System.out.println("默认方法");
     }

      //静态可以直接通过接口名调用
      static void test1(){
          System.out.println("静态方法");
      }

}

/*
一个类实现接口
 要么将此类声明为抽象类
 要么重写所有抽象方法,可以重写默认方法,也可以不重写
 接口是用来被其他类实现，不能被实例化
 一个类可以直接继承一个类
 一个类可以实现多个接口
 多个类可以实现同一个接口。
 */
//public abstract class MyInterfaceImpl implements MyInerface{
public  class MyInterfaceImpl extends Object implements MyInerface,InterfaceC{

        @Override
        public void eat() {
            System.out.println("MyInterfaceImpl--eat");
        }
       @Override
        public void test() {
            System.out.println("MyInterfaceImpl--test");
        }
}

与继承关系类似，接口与实现类之间存在多态性。

//接口实现多态性
Animal cat = new Cat();
Animal dog = new Dog();