作业十总结笔记

目录

什么是多态?

多态的三要素：1.继承 2.重写 3.父类引用指向子类对象。

静态内部类

内部类的继承

 接口的定义  接口：方法定义和常量值的集合

final关键字的功能概述

1、用来修饰一个引用

2、用来修饰一个方法

​

3、用来修饰类

方法的重载和重写都是实现多态的方式，

重载

重写

重构

创建Pad3类继承Computer2类,并重写父类的showPicture方法

向上转型

向下转型

接口和抽象类的区别:

抽象类：abstract

​

什么是多态?
程序运行过程中 , 对象角色的切换 , 对象行为的扩展

多态的三要素：1.继承 2.重写 3.父类引用指向子类对象。
多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。
多态：程序运行过程中，对象角色的切换：如老师，在家是丈夫或妻子，在校是老师

程序运行过程中，对象行为的扩展：如孵蛋器：把鸡蛋/鸽子蛋->孵出小鸡和鸽子

静态内部类
1、一个静态内部类中可以声明 static成员，但是在非静态内部类中不可以声明静态成员
2、静态内部类有一个最大的特点，就是不可以使用外部类的非静态成员，所以静态内部类在程序开发中比较少见
3、静态内部类不可以直接调用外部类的非静态成员变量
4、进行程序调试时，如果在每一个 Java 文件中都设置一个主方法，将出现很多额外代码，而程序本身并不需要这些主方法，为了解决这个问题，可以将主方法写入静态内部类中

内部类的继承
必须要满足四个条件：
1、继承内部类的前面要跟随外部类名+"."
2、在某个类继承内部类时，必须硬性给予这个类一个带参数的构造方法
3、并且该构造方法的参数为需要继承内部类的外部类的引用
4、在构造方法体中使用a.super()语句，这样才为继承提供了必要的对象引用

class Computer {//父类：电脑 
            
            String screen="液晶显示屏";
            void startup() {
            System.out.println("电脑正在开机，请等待...");
            }
            } 
public class Pad2 extends  Computer {
    String battery="5000毫安电池";// 子类独有的属性
    public static void main(String[] args) {
    Computer pc = new Computer();// 电脑类
    System.out.println("computer的屏幕是："+pc.screen);
    pc.startup();
    Pad2 ipad = new Pad2();//平板电脑类
    System.out.println("pad的屏幕是："+ ipad.screen);//子类可以直接使用父类
    System.out.println("pad的电池是："+ipad.battery);//子类独有的属性
    ipad.startup();// 子类可以直接使用父类方法
}
}

 接口的定义  接口：方法定义和常量值的集合
接口的特点：

1、接口是一种特殊的抽象类，只包含常量和方法的定义，而没有方法的实现。

2、通过接口可以指明多个需要实现的方法，而不需考虑这些类之间的层次关系。

在类体中可以使用接口中定义的常量，必须实现接口中定义的所有方法。

3、一个类可以实现多个接口，在implements字句中用逗号隔开。

interface drawTest {//定义接口
public void draw();
// 定义方法
}
//定义平行四边形类，该类实现了drawTest接口
 class ParallelogramgleUseInterface implements drawTest {
        public void draw(){//由于该类实现了接口，所以需要覆盖draw()方法
            System.out.println("平行四边形.draw()");
        }}
        //定义正方形类，该类实现了drawTest接口
        class SquareUseInterface implements drawTest{
        public void draw() {
        System.out.println("正方形.draw()");
        }}
        public class QuadrangleUseInterface{//定义四边形类
        public static void main(String[] args) {
        drawTest[]d={//接口也可以进行向上转型操作
        new SquareUseInterface(), new ParallelogramgleUseInterface()}; 
        for(int i = 0; i < d.length; i++) {
        d[i].draw();// 调用draw()方法
        }}}

final关键字的功能概述
final关键字可以用来修饰引用、方法和类。

给final关键字修饰的成员变量赋值有两种方式：1.直接赋值。2.在构造方法中赋初值。

1、用来修饰一个引用
如果引用为基本数据类型，则该引用为常量，该值无法修改；

如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。

如果引用时类的成员变量，则必须当场赋值，否则编译会报错。

2、用来修饰一个方法
当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承。

当类被final关键字修饰，表示这个类是不能被继承的。final关键字修饰类例子

//定义Fruit类
final class Fruit{
//info()方法
public void info(){
        System.out.print("fruit");
  }
}
//定义Cherry继承Fruit类
class Cherry extends Fruit{
//infor()方法
public void info(){
        System.out.print("cherry");
  }
}
public class A {
public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cherry c=new Cherry();//实例化子类Cherry对象
        c.info();//调用info()方法
  }
}

3、用来修饰类
当用final修饰类时，该类成为最终类，无法被继承，该类就不能被其他类所继承

1、super表示超（父）类的意思，this表示对象本身

2、super可用于访问父类被子类隐藏或着覆盖的方法和属性，使用形式为super.方法（属性）

3、在类的继承中，子类的构造方法中默认会有super()语句存在(默认隐藏)，相当于执行父类的相应构造方法中的语句

方法的重载和重写都是实现多态的方式，
重载
构造函数是一种特殊的函数，使用构造函数的目的是用来在对象实例化时初始化对象的成员变量。由于构造函数名字必须与类名一致，我们想用不同的方式实例化对象时，必须允许不同的构造方法同时存在

重写
重写（又叫覆盖）是继承的实现方式之一，也就是说只有在子类中才会出现方法的重写。重写是指在子类中保留父类成员方法的名称不变，参数列表不变，重写成员方法的实现内容，修改成员方法的返回值类型，或更改成员方法的存储权限。

重构
重构是继承中一种特殊的重写方式，只重写子类方法中的实现内容，成员方法的名称，参数类型、个数及成员方法的返回值都保持不变。

创建Pad3类继承Computer2类,并重写父类的showPicture方法

class Computer2{//父类：电脑
 void showPicture(){
     System.out.println("手指点击触摸屏");
 }}
public class Pad3 extends Computer2{//子类：平板电脑
     void showPicture() {
         System.out.println("手机点击触摸屏");
     }
     public static void main(String[] args) {
         Computer2 pc=new Computer2();// 电脑类
         System.out.print("pc打开图片：");
         pc.showPicture();
         Pad3 ipad=new Pad3();//平板电脑类
         System.out.print("ipad打开图片：");
         ipad.showPicture();//重写父类方法
         Computer2 computerpad=new Pad3();//父类声明,子类实现
         System.out.print("computerpad打开图片：");
         computerpad.showPicture();//调用父类方法,实现子类重写的逻辑
     }}

向上转型
1. 本质：父类的引用指向了子类的对象。
2. 语法：父类类型  引用名  =  new  子类类型();

class Quadrangle {//四边形类
public static void draw(Quadrangle q) {
//SomeSentence
//四边形类中的方法
    }
}
public class Parallelogram extends Quadrangle{ //实例化平行四边形类对象引用
public static void main(String args[]) {
Parallelogram p = new Parallelogram(); //调用父类方法
draw(p);
}
}

向下转型
1. 语法：子类类型  引用名  =  (子类类型) 父类引用。

区别在于前者实现的是编译时多态，后者实现的是运行时多态。

重载:重载发生在一个类中，同名的方法如果有不同的参数列表（参数的类型不同、参数的个数不同或者二者都不同）

重写:重写发生在子类与父类之间，即在子类中重写从父类继承的方法，重写要求子类被重写方法和父类被重写方法有相同的参数列表返回类型.构造方法不能被重写，声明为final的方法不能被重写，声明为static的方法不能被重写，但能被再次声明。

接口和抽象类的区别:
1.抽象类允许包含某些方法的实现，而接口是不允许的；从设计级别看，为了实现由抽象类定义的类型，一个类必须定义为一个抽象类的子类，这限制了它在类图中的层次，但是接口没有这个层次的限制。

2.在抽象类中提供成员方法的实现细节，该方法只能在接口中为 public abstract修饰，也就是抽象方法。

3.抽象类中的成员变量可以实现多个权限 public private protected final等，接口的变量都是静态常量，默认使用public static final修饰，不能修改

抽象类：abstract
//抽象类

public abstract class Action {
    
    //普通方法
    public void run(){
        System.out.println("run");
    }
 
    //抽象方法
    //abstract，抽象方法，只有方法名，没有方法的实现
    public abstract void fly();
    public abstract void eat();
 
    public static void main(String[] args) {
        //Action action=new Action(){}  报错，必须重写所有的抽象方法
        Action action=new Action()
        {
            //实现抽象类中的所有抽象方法
            public void fly() {
                System.out.println("fly");
            }
 
            public void eat() {
 
            }
        };
        action.fly();
        action.run();
    }
}