JAVA入门基础6**（系列更新）———面向对象（二）的继承，抽象，接口-CSDN博客

本文链接：https://blog.csdn.net/niwad/article/details/113448605

JAVA入门基础6（系列更新）———面向对象（二）的继承，抽象，接口

面向对象2

面向对象2

大致总结

封装：封装就是将客观的事物抽象成类，类中存在属于这个类的属性和方法。
继承：继承就是把父对象继承过来，这样子类就存在了父类的操作方法，java是单继承，就是只能继承一个父对象。
多态：多态就是程序中允许出现重名现象，java实现多态的方式有方法重载和成员变量覆盖两种形式。

继承

上课的时候我们讲解的是这个例子

现在需要制作一个媒体资料库；
可以向资料库存放图片、视频；
资料库可以对其包含的所有的图片/视频进行遍历，展示其信息；
图片:title;size;format;px;isCopy
视频:title;size;format;playingTime;isCopy

我们来自己做一个新例子

现在需要制作一个学生系统管理库；
可以输入存放姓名，学号，学生的照片；
资料库可以对学号，姓名，照片进行遍历，展示其信息；
学号：usernum
姓名：username
头像照片：title;size;format;px;isCopy
自我介绍：title;size;format;word

public class demo1 {
    ArrayList<Item> items=new ArrayList<Item>();
    public void add(Item item){
        items.add(item);
    }
    public void list(){
        for(Item zz:items){
            zz.show();
        }
    }
}

public class Item {
    private String username;
    private int usernum;
    private String title;
    
    private int size;
    private String format;
    public Item() {
    }

    public Item(String username，int usernum,String title, int size, String format) {
        this.username = username;
        this.usernum=usernum;
        this.title = title;
        this.size = size;
        this.format = format;
    }
    public void show(){
        System.out.println( "/"+username"/"usernum+":"+title+"."+format);
    }
}

public class zaopian extends Item {
    private int px;
    private boolean isCopy=true;
    public zaopian(String title, int size, String format, int px) {
        super(title,size,format);
        this.px = px;
    }
    @Override
    public void show(){
        System.out.print("学生照片:");
        super.show();
    }
}

public class word extends Item{

    private word;

    public word(String title,int size, String format, String word) {
        super(title,size,format);
        this.word = word;
    }

@Override

@Override-------------------这个用于重写父类方法用的，用这个注解可以避免方法名跟参数写错。

@Override
 public void show(){
     System.out.print("自我介绍：");
     super.show();
 }
}

super();的应用

super();方法向父类传递对应的参数,

调用顺序

子类调用方法时优先调用自己

构造顺序

父类构造->子类的定义初始化->构造器初始化

多态

什么是多态？？？

（自己的话解释）：
多态就是对同一个对象，在不同时刻表现出来的不同形态；

（上课的内容）：
一个变量可以管理自己或子类的对象的现象叫多态

多态有什么用？？？

子类的对象可以被当作父类的对象来使用

多态使用方法（概念）？？？

赋值给父类的变量
传递给需要父类对象的函数
放进存放父类对象的容器里

public class way1 extends did{
@Override
public void doit() {
System.out.println(“way1 done”);
}
//自己独有
public void way1pro(){
System.out.println(“way1 completed ”);
}
}

public class way2 extends did {
@Override
public void doit() {
System.out.println(“way2 done);
}
//自己独有的方法
public void way2pro(){
System.out.println(“way2 completed ”);
}
}

造型

这里还是要较多的以上课内容为主

什么是造型？？？

把一个类的实例对象赋值给另外一个类的变量的过程叫做造型

造型要知道的概念？？？

父类的变量可以管理子类的对象（向上造型）
子类的变量不能管理父类的对象

造型具体方法举例？？？

此处引用上课的例子：

 Vehicle v=new Vehicle();
 Car c=new Car();
 v=c;	//可以
 c=v;	//编译错误！会爆红

向上向下造型

下为举例区分向上向下造型；

	class A {
	}
 
	class B extends A {
	}
 
	A a = new A();
	B b = new B();
 
	A a1 = b;// 向上造型
	B b1 = (B) a1; // 向下造型
	B b2 = a; // ClassCastException,a的类型是A,实例化也是A

除非用向下造型，c=(Car)v; 但是前提是v管理的的确是一个Car的对象

需要注意事项：

向上造型总是安全的，是默认的，不需要加括号
向下造型是强制的，是不安全的，可能会发生异常
造型不是类型转换

造型总结

**向上造型：**

*父类引用指向子类对象（子类型，实例也是子类的实例化）；*

**向下造型：**

*子类引用指向父类对象（父类型，实例是子类的实例化）；*

抽象

什么是抽象？？？

abstract修饰符修饰的对象

现在需要做三个类

矩形，三角形，圆形

每个类里面都需要有计算周长的方法getPerimeter();

和计算面积的方法getArea();

抽象类和抽象方法（abstract）

抽象方法——表达概念而无法实现具体代码的方法
抽象类——表达概念而无法构造出实体的类
有抽象方法的类一定是抽象类，但是抽象类不一定只有抽象方法
继承自抽象类的子类一定要重写父类中的抽象方法

两种抽象

与具体相对
- 表达概念而非实体
与细节相对
- 关注大局而不过分在意具体实现

接口

接口概念

 接口就是一个规范和抽象类比较相似。它只管做什么，不管怎么做。通俗的讲，借口就是某个事物对外提供的一些功能的声明，其定义和类比较相似，只不过是通过interface关键字来完成

知识点

1.接口属性默认：public static final-----；

2.接口方法默认：public abstract-----；

上课内容：

现在有一个手机类Phone，和人类Person

两者都有发出声音的方法Sound();

我们想把这个公共的方法提取出来但是又不违和；

public interface Soundable{
    public void sound();
}

public class Phone implements Soundable{
    @Override
    public void sound(){
        System.out.println("叮铃铃");
    }

}

public class Person implements Soundable {
    @Override
    public void sound(){
        System.out.println("你好");
    }
}

接口的一些机制

接口里的所有方法都是抽象方法，即使前面没有加abstract声明，系统会自动默认
接口里的所有变量都是静态变量
接口可以继承接口，但不能继承类
接口不能有实体
一个类可以实现多个接口，实现用关键字 implements

接口存在的意义

将某个功能抽象出来，提高可扩展性
是Java成功的关键之一，因为极适合多人写一个大程序
也是Java被批评的要点之一，因为容易造成代码膨胀