Java语言-----封装继承抽象多态接口

Posted tq02

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java语言-----封装继承抽象多态接口相关的知识，希望对你有一定的参考价值。

目录

前言     

一.封装

1.1封装的定义

1.2访问修饰符的使用

二.继承

 2.1继承的定义

2.2继承的方法

2.3继承使用注意点

三.多态

3,1多态的定义

3.2动态绑定

3.3方法重写

3.4向上（向下）转型

四.抽象

4.1抽象的概述和定义

 4.2抽象的使用

五.接口

5.1接口的意义

5.2接口的定义

总结

😽个人主页： tq02的博客_CSDN博客-C语言,Java领域博主

 🌈理想目标：努力学习，向Java进发，拼搏一切，找到一份朝九晚五，有假期的工作，让自己的未来不会有遗憾。
 🎁欢迎各位→点赞👍 + 收藏⭐ + 评论📝+关注✨

     本章讲解内容：Java封装、继承、抽象、多态、接口

      使用编译器：IDEA

前言     

         在讲述封装、继承、抽象、多态、接口前，我们得先了解一下，什么是类与对象，类与对象的详细讲解：tq02的类与对象讲解

一.封装

1.1封装的定义

         封装，在类里操作，将类的成员变量和成员方法进行封装处理，意义：可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。而对类进行封装我们需要使用访问修饰符，一共分为四种，

访问修饰符         private     default    protected     public
同一包的同一类           √         √        √      √
同一包的不同类         √         √        √
不同包的子类         √        √
不同包的非子类         √

 注：1.如果成员变量或者成员方法没有使用封装则是默认使用default修饰符。

         2.包是存放多个类的容器，就是防止在工程建立时，和其他人写的类名相同而起冲突。

         3.子类是在继承当中可以学到的。

1.2访问修饰符的使用

   我们进行四种封装代码实例图

1.private修饰

 private修饰的price和name变量，其他类无法访问，只有自己的类里可以进行访问。就例如在BookList类里无法直接访问这两个元素变量。

2.default修饰

 default修饰符，是指当你没有标注修饰符时，就默认了default修饰符，而此类的只有同一个包的其他类访问，例如BookList可以访问，但不同包的Student类无法访问。

3.protected修饰符

 protected修饰符，类当被修饰了之后，同包下所有的类都可以访问，非同包下的其他包的子类也可以使用。如Student类继承之后也可以使用Book类。

4.public修饰符

 public修饰符，一旦使用，所有的类都可以使用，不在乎是否同包。

二.继承

 2.1继承的定义

       继承是什么？是所有OOP语言不可缺少的组成成分，是面向对象的三大特征之一，继承就相当于，孩子继承父亲的东西（父亲愿意给孩子的东西），关键字是extends，继承父类的成员变量和成员方法，一般是为了减少代码冗余。但是继承也得遵守访问修饰符，一旦不符合，则无法继承。

代码显示：

public class Animal 
    public String name;
    public Animal(String name) 
    this.name = name;
    
    public void eat(String food) 
    System.out.println(this.name + "正在吃" + food);


// Cat.java
class Cat 
    public String name;
    public Cat(String name) 
    this.name = name;
    
    public void eat(String food) 
    System.out.println(this.name + "正在吃" + food);


// Bird.java
class Bird 
    public String name;
    public Bird(String name) 
    this.name = name;
    
    public void eat(String food) 
    System.out.println(this.name + "正在吃" + food);
    
    public void fly() 
    System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");

 可以看得出来，Animal类和cat类还有Bird类，有很多重复的代码，而为了减少大量的冗余代码，我们可以使用继承的手段。

2.2继承的方法

定义方法：

class 子类 extends 父类

 代码实现：

class Animal 
    public String name;
    public Animal(String name) 
    this.name = name;

    public void eat(String food) 
    System.out.println(this.name + "正在吃" + food);
    


class Cat extends Animal 
    public Cat(String name) 
    // 使用 super 调用父类的构造方法.
    super(name);
    


class Bird extends Animal 
    public Bird(String name) 
    super(name);

    public void fly() 
    System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    

public class Test 
    public static void main(String[] args) 
    Cat cat = new Cat("小黑");
    cat.eat("猫粮");
    Bird bird = new Bird("圆圆");
    bird.fly();

我们可以看出，Cat类和Bird类的成员变量和成员方法相当于是在Animal类的基础上，扩展出来。

2.3继承使用注意点

  1. 使用 extends 指定父类.
  2. Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
  3. 子类会继承父类的所有 public 的变量和方法.
  4. 对于父类的 private 的字段和方法, 子类中是无法访问的.
  5. 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用
  6. 所有的类都有一个父类---Object类

三.多态

3,1多态的定义

        多态是面向对象三大特征最后一个，可以增强程序的扩展性，提高程序的可维护性。而它的主要支撑技术有向上转型、向下转型、动态绑定、方法重写。

3.2动态绑定

          即方法与方法的主体在运行时才进行绑定。例如，当父类和子类拥有一个同名的方法（remove），那么定义了an.remove()，remove方法的调用主体是an，但是an只有调用时，才能知道是实例化了哪个类。而这便是动态绑定。

3.3方法重写

        当子类和父类的成员方法名相同时，那么子类的成员方法便是方法重写。而当子类的对象实例化之后，使用和父类同名的方法，则使用的子类的方法，不是使用父类的方法。

class Animal 
    public String name;
    public void Name(String name) 
     System.out.println("Animal的名字是"+name);

    


class Cat extends Animal 
   
      public void Name(String name) 
     System.out.println("Cat的名字是"+name);


public class Test 
    public static void main(String[] args) 
   Cat cat = new Cat();
   cat.Name("小黑");

 该代码的结果是Cat的名字是小黑，由此可见，使用的Cat类的Name方法，而不是Animal类的Name方法。

3.4向上（向下）转型

 向上转型和向下转型都是在继承的基础上

class Animal 
    public String name;
    public Animal(String name) 
    this.name = name;

    


class Cat extends Animal 
    public int age;
    public Cat(String name) 
    // 使用 super 调用父类的构造方法.
    super(name);
    
    public void eat(String food) 
    System.out.println(this.name + "正在吃" + food);
    

public class Test 
    public static void main(String[] args) 
    Animal cat = new Cat("小黑");
   cat.eat();

从上面代码中，我们可以发现cat是Animal的引用变量，而它指向了子类的对象，这就是向上转型。

注：

  1. cat是Animal类型的引用变量，而对于Animal类型的引用变量来说，是无法得知age子类成员变量的，所以无法使用cat.age=22;进行赋值的。
  2. 由于cat实际上指向Cat的对象，所以当调用eat()方法时；依然还能显示子类成员方法的信息。
public class Animal 
    protected String name;
    public Animal(String name) 
        this.name = name;
    
    public void eat(String food) 
        System.out.println("我是一只小动物");
        System.out.println(this.name + "正在吃" + food);
    

public class Bird extends Animal 
    public Bird(String name) 
        super(name);
    

    public void eat(String food) 
        System.out.println("我是一只小鸟");
        System.out.println(this.name + "正在吃" + food);
    

    public void fly() 
        System.out.println(this.name + "正在飞");
    

    public static void main(String[] args) 
        Animal animal = new Bird("圆圆");
        //强制转换为Bird类型
          Bird bird = (Bird)animal;
          bird.fly();

 从上面代码中，我们可以很明显的发现向下转型需要通过强制类型转换完成。虽然animal是Animal父类的引用变量，但是将animal强制转换为Bird类型便为向下转型。但是并不安全，因为向下转型可能会不正确，例如原本向下转型为Cat类，但却转型为了Bird类，这便会产生危险性。

解决方法：

Animal animal = new Cat("小猫");
if (animal instanceof Bird) 
Bird bird = (Bird)animal;
bird.fly();

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。

结论：1.向上转型时，是父类的引用变量指向了子类的对象，当然，无法使用子类的新增成员（变量和方法），但是如果使用父类的成员方法，如果子类有该方法的重写，则使用重写的方法，若无，则使用父类方法。

        2.向下转型时，则需要强制类型转换。

四.抽象

4.1抽象的概述和定义

        抽象类，关键字为abstract，如果所有的子类都要重写父类的某个方法时，父类的方法可以为抽象方法，直接声明，不需要结构体。而含有抽象方法的类，则为抽象类
定义方法：

               public abstract  类名

                String name;

                public abstract void 方法名();

 4.2抽象的使用

        抽象类存在的最大意义就是为了被继承.
         抽象类不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。

abstract class  Animal 
    public String name;
    public Animal(String name) 
    this.name = name;

    public abstract void eat(String food); //抽象方法，子类一定要重写


class Cat extends Animal 
    public Cat(String name) 
    // 使用 super 调用父类的构造方法.
    super(name);
   //重写父类的抽象方法
   public abstract void eat(String food)
     System.out.println("猫吃"+food);
    
    


class Bird extends Animal 
    public Bird(String name) 
    super(name);

   //重写父类的抽象方法
    public abstract void eat(String food)
     System.out.println("鸟吃"+food);
    

public class Test 
    public static void main(String[] args) 
    Cat cat = new Cat("小黑");
    cat.eat("猫粮");
    Bird bird = new Bird("圆圆");
    bird.fly();

抽象的重点知识：

  1. 抽象类不能直接实例化。
  2. 抽象方法不能是 private 的。
  3. 抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用。

五.接口

5.1接口的意义

          接口是为了弥补代码无法多继承，只能单继承的问题。例如定义了一个Animal的父类，和Cat、Bird、Dog、Wolf的子类，可是你想啊，狗和猫是宠物，或许有共同的方法，定义一个宠物类，那么可以通过接口实现不相关类的相同行为。

好处：

  1. 利于代码的规范，目的是给开发人员一个清晰的指示，告诉他们哪些业务需要实现；同时防止由于开发人员随意命名而导致命名不清晰和代码混乱，影响开发效率。 
  2. 是有利于对代码进行维护，定义一个接口，把功能菜单放在接口里，然后定义类时实现这个接口。
  3. 是保证代码的安全和严密。

5.2接口的定义

定义方法：

         public interface  接口名

使用接口：

        class  类名   implements  接口名 方法体 ；

代码实现： 

class Animal 
    public String name;
    public Animal(String name) 
    this.name = name;
    
    

   //定义接口
public interface Eat 
     public void eat(String food);

                      //使用接口
class Dog extends Animal implements Eat
    public int age;
    public Cat(String name) 
    // 使用 super 调用父类的构造方法.
    super(name);
    
    public void eat(String food) 
    System.out.println(this.name + "正在吃" + food);
    

                        //使用接口
class Cat extends Animal implements Eat
    public int age;
    public Cat(String name) 
    // 使用 super 调用父类的构造方法.
    super(name);
    
    public void eat(String food) 
    System.out.println(this.name + "正在吃" + food);
    

public class Test 
    public static void main(String[] args) 
    Animal cat = new Cat("小黑");
   cat.eat();

接口的重点：

  1. 接口的方法体若为空，则为空实现。
  2. 一个类可以有多个接口。
  3. 接口里所有的方法都是public和抽象的，所以可以省略public和抽象的。
  4. 接口无法被实例化。
  5. 接口可以被继承

总结

      继承是多态、抽象的基础，而学会了抽象，才能理解接口。而这些知识都是Java最为重要的面向对象三大特征的。只有细心学习，才能更近一步，在Java上才能算正式起步。

Java语言简介基础组成封装继承多态抽象类内部类接口

目录

Java简介

  • Java版本

J2EE （企业版） J2SE（标准版） J2ME（小型版）

  • Java特性

跨平台

  • JVM、JRE、JDK介绍
  1. JVM(Java虚拟机)
    不同平台上装指定版本虚拟机，就能运行Java程序
  2. JRE(Java运行环境)　　
    包括JVM和Java程序所需的核心类库
  3. JDK(Java开发程序包)
    包括JRE

　　 　　　　

综上，所以安装JDK就可以了
使用JDK开发的java程序，交给JRE运行
JRE=JVM+类库　　　　
JDK=JRE+java开发工具

  • DOS命令行
  1. dir列出目录　　　　
  2. cd 改变目录　　　　
  3. cd..后退　　　　
  4. cd根目录　　　　　　
  5. md创建目录　　　　
  6. rd 删除　　　　　　
  7. del 删除（文件） *通配符
  8. help寻求帮助，可以查用法
  9. Java -version用来在命令行中查看使用的Java版本
  • 环境变量表示方法

%变量名%

  • 临时设置

Path=haha(这个haha是代表任意值) 在当前命令行窗口有效

  • 文件夹选项可以选择不要隐藏扩展名　　
  • classpath临时环境变量　　　　

Java语言基础组成

  • 关键字(都是小写, 类名大写)
  • 标识符

数字不能开头，不可以使用关键字（标识符里有-和$符号）

  • 注释

//单行注释 　　　/ * 多行注释/　　　/ * * 文档注释/
注释可以嵌套，但多行不能套多行　　　　
javadoc可提取（Java特有）
可以使用注释，进行逐段调试

　　　　

注释的应用：
/ * 需求：练习...思路：
1、...2、...3、...步骤：
1. 用class关键字完成定义；
2. 主函数：固定格式；
3. 输出语句*/

  • 常量与变量

整数、小数、布尔、字符、字符串、null常量

  • 进制　　

byte字节=8个二进制位

  • 负数

四个字节表示

  • 变量

变量作用范围（一对{}之间有效）
格式：数据类型 变量名=值；

  • 数据类型
  1. 整数：byte（1位）、short（2位）、int(默认)（4位），long（8位）
  2. 小数：float（4个字节）,double（默认）（8个字节）
  3. 字符：char（2个字节，一个中文正好两个字节）
  4. 布尔：boolean（只有True和False）
  • 类型转换
  1. 自动类型转换
  2. 强制类型转换（丢失精度）

字符+数，显示ACSII码
字符类型运算过程（Java底层用Unicode码）

  • 运算符
  1. 类型运算符细节（byte担心存不下，Integer.Max_VALUE(int 型最大值)）
  2. 算数运算符
  • 　- * / %（取余） +（连接符）
    ++ --(在原来的基础上自加自减1)
  1. 赋值运算符

=、+=、-=、*=、......

注意:+=不等于=......+......（+=在赋值中做了强制转换，=...+....是两步运算）

  1. 比较运算符

运算完结果必须是True或者False
== 　　!=　　>　　<　　<=　　>=

  1. 逻辑运算符
  1. &用于连接两个布尔类型的表达式
  2. &与|或　　&运算特点
  3. ^异或：两边相同为假 　　
  4. ！非
  5. &&和&运算结果一样，但过程有点小区别　　　　
  6. &右边始终参与，&&左为假，右不参与
  7. ||左边为真，后边不参与
  1. 位运算符

<<左移　　>>右移　　>>>无符号右移

　　　　　　　　

左移几位就是乘以2的几次方，
右移：以前最高位是啥就拿啥补空位，右移就是该数据除以2的几次幂
无符号右移：右移，高位出现的空位用0补

例子: 两个数互换问题：

  1. 引入第三方变量
  2. a=a+b;　　　　b=a-b;　　　　a=a-b;
  3. a=a^b;　　　　b=a^b;　　　　a=a^b;
  1. 三元运算符

（条件表达式）？表达式1：表达式2；

  • 程序流程控制

顺序结构　　选择结构　　循环结构

  1. 选择结构
if（条件表达式）　
{　　　　
	执行语句；　　
}

if（条件表达式）
{
	执行语句；　　
}　　
else{　　
	执行语句；　　
}

if ........
else if...........
else   if........　　
else

当if.....else......运算后有具体结果，可以用三元运算符代替

　代码块：局部代码可以定义局部变量周期

　　　　　　　　　　

switch（表达式）{　　
	case　　取值1：
		执行语句；
		break；　　
	case  取值2：
		执行语句；
		break；　　
	default：
		执行语句；
		break；
}　　　　
//挨着大括号的break可以不用写
  1. 循环结构
while（条件表达式）{　
	执行语句；　　
}

do{　　
	执行语句；
}while（条件表达式）;

for（初始化表达式；循环条件表达式；循环后表达式）{
	...
}

其他流程控制语句：continue（继续）；break（跳出）；

　　　　

  • 函数

　　　　　　　

定义在类中具有特点功能的一段独立小程序
函数也称方法；
可以将代码封装，复用；

重载:(重复载入）：在同一个类中，允许存在一个以上的同名函数，只要参数个数或者参数类型不同即可；

  • 数组

同一类型数据的集合，其实就是一个容器

　　　　　　　

当访问到数组中不存在角标时会发生异常

//格式1：
//元素类型【】　　数组名=new　　元素类型【元素个数或数组长度】；
int【】　　arr=new 　　int【3】；

//格式2：
//元素类型【】　　数组名=new　　元素类型【】{元素，元素，...};
  • 堆栈

堆特点：存储实体（一堆数据），不能消失；
栈的特点：先进后出

　　　　　　　　　　　

栈：引入（指向）堆中的数据　　引入（指针）
堆： 垃圾回收机制：自动不定时回收堆中的垃圾

　　　　　

内存空间的划分：局部代码块；决定局部变量生命周期

  • 正向遍历，反向遍历(数据结构)
  • 排序（选择排序、冒泡排序、排序位置置换代码提取）

面向对象

三个特征：封装、继承、多态

对象

用Java语言对现实生活中事物描述，通过类的形式体现
对事物描述两方面：

  1. 属性
  2. 行为

对象就是该类事物实实在在个体
引用数据类型参数传递

封装

private私有，只在本类中有效，其他类就算创建对象也访问不到

public       void　　函数名（）{
	....　　　　
}

　　　　　　

封装隐藏实现细节、对象属性、仅对外提供公共访问方式
优点：

  1. 安全性；
  2. 便于隔离；
  3. 提高重用性；
    私有仅仅是一种体现形式（封装的）

Java语言中最小的封装体是函数

构造函数

  • 特点
  1. 函数名与类名相同
  2. 不用定义返回值类型
  3. 没有具体返回值

　　　　　　　　　　

  • 作用

给对象初始化；

　　　　　　　　　　

一个类中如果没有定义构造函数，该类中会有一个默认的空参数构造函数

　　　　　　　　　　

  • 一般函数和构造函数区别
  1. 构造函数：对象创建时就会调用与之对应的构造函数初始化
  2. 一般函数：对象创建后，需要时才调用

　　　　　　　　　　

  • 什么时候定义构造函数?

在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中；

  • 构造函数细节
  1. 对象改名：p1.setname("小强");
  2. 构造函数加void成一般函数；

this关键字

  • this(当局部变量和成员变量重名时，可以用关键字this区分)

　　　 　　

this代表对象，当前对象
this就是所在函数所属对象的引用
简单来说，哪个对象调用了所在的函数，this就代表哪个对象

  • 构造函数调用构造函数，用this调用成员

对this的调用必须是构造函数第一个语句，因为初始化动作要先执行

  • 只要在本类中用本类对象，用this

static（静态关键字）

　　

静态数据可以被对象调用，类调用

  • 特点
  1. static是一个修饰符，用于修饰成员；
  2. static修饰的成员被所有对象共享；
  3. static优先于对象存在，因为static随着类的加载已经存在；
  4. static修饰的成员多了一种调用方式，可以用类名调用；
  5. static存储共享数据，类中的私有
  • 成员变量（实例变量）和静态变量（类变量）的区别：
  1. 生命周期：
    成员变量随着对象的创建而存在，随着对象的被回收而释放；
    静态变量随着类的加载而存在，随着类的消失而消失；
  2. 调用方式不同：
    成员变量只能被对象调用;
    静态变量可以被对象调用，也可以类名调用；
  3. 别名不同：
    成员变量（实例）
    静态变量（类变量）
  4. 存储位置：
    成员变量在堆中；
    静态变量存在方法区（的静态区）共享数据区；
  • 静态使用注意事项
  1. 静态方法只能访问静态成员（非静态方法可以访问静态成员，也可以访问非静态成员）
  2. 静态方法不可以使用this，super关键字
  3. 主函数是静态的，只能访问静态的；

主函数

public　　static　　void　　main(String[]　　args)
  • 主函数特殊之处
  1. 格式是固定的
  2. 被JVM所识别和调用

public：因为权限必须是最大的
static：不需要对象，直接用主函数所属类名调用即可；
void：主函数没有具体返回值；
main：函数名，不是关键字，只是JVM识别的名字
String[] args：主函数参数列表是一个数组类型的参数，而且元素都是字符串类型；

静态什么时候用呢？

  1. 静态变量：
    当分析对象中所具备的成员变量的值是相同的，只要数据在对象中都是不同的，就是对象特有数据，必须存储在对象中；
  2. 静态函数：
    从源代码看，该功能是否需要访问非静态成员变量（可以加，可以不加的时候，最好加上，不浪费内存）
  3. 静态代码块：
    随着类的加载而执行，而且只执行一次 作用：用于给类进行初始化；
  4. 构造函数代码块：
    构造函数具有初始化对象针对性；

　　　　　　　　　　　　　

面向对象（数组工具对象建立）

  • 文档注释：建立一个用于操作数组工具类，其中包含着常见的数组的函数，如最值，排序等
  • 文档能提取的是公有的

设计模式

对问题行之有效的解决办法，其实他是一种思想；

　　　　　

继承

好处：

  1. 提高代码复用性；
  2. 让类之间产生关系，给多态提供了前提；
  • 父类
  • 子类

Java中支持单继承，不直接支持多继承，但对C++的多继承进行了改良

  • 单继承：一个子类只能有一个直接复类

  • 多继承：一个子类可以有多个直接父类（Java中不允许，进行了改良）会产生不确定性，不直接支持，因为父类中有相同成员会产生调用的不确定性；

  • Java支持多重继承：C继承B，B继承A

因此出现继承体系：

  1. 查看体系顶层类，了解体系基本功能；
  2. 创建体系最子类对象，完成功能使用。
  • 什么时候定义继承呢？

当类与类之间存在所属关系时候，就定义继承；

  • 在子父类中，成员的特点体现：

1、成员变量；2、成员函数；3、构造函数；

成员变量

当本类的成员和局部变量同名用this区分；
当子父类中的成员变量同名用super区分父类；

this和super用法很相似：
this代表一个本类对象的引用
super代表一个父类空间

子父类中成员函数特点

1. 覆盖：当子父类中出现成员函数一模一样，会运行子类情况，这种现象称为覆盖；　　

函数两个特点：

  1. 重载:在同一类中
  2. 覆盖:子类中，覆盖也称为重写；

覆盖注意事项：

  1. 子类方法覆盖父类方法时，子类权限必须大于等于父类权限；
  2. 静态只能覆盖静态，或被静态覆盖；
  • 什么时候覆盖操作？

当对一个类进行子类扩展时，子类需保留父类功能，但要定义子类特有

子父类中的构造函数——子类的实例化过程

  • 在子类构造对象时，发现访问子类构造函数时，父类也运行了；

原因：在子类中构造函数中第一行有一个默认隐式语句，super()

  • 子类的实例化过程：子类中所有构造函数都默认访问父类构造函数
  • 为什么子类继承父类要访问他们的构造函数？

那是因为子类继承父类，获取了父类内容，所以使用父类内容前，先看父类如何对自己内容初始化

注意：super语句必须定义在子类构造函数第一行

一个对象实例化过程

person.p=new person()
  1. JVM会读取指定路径下person.class文件，并加载进内存，并会先加载person父类；
  2. 在堆内存中开辟空间，分配地址；
  3. 并在对象空间中，对对象属性默认初始化；
  4. 调用对应构造函数初始化；
  5. 构造函数中，第一行先调用父类构造函数；
  6. 父类初始化完后，对子类属性初始化；
  7. 在进行子类构造函数特定初始化；
  8. 初始化完毕后，将地址值赋给引用变量；

final关键字：继承的弊端：打破了封装性；

  1. final是一个修饰符，可以修饰类、方法、变量；
  2. final修饰的类不可以被继承；
  3. final修饰的方法不可以被覆盖；
  4. final修饰变量是一个常量，只能赋值一次；
  • 为什么要用final修饰变量，其实在程序中如果数据固定，则直接用就可以？

为了区别；

抽象类

  • 抽象：abstract /抽象关键字/

没有足够的信息描述一个类就是抽象类；

  • 特点
  1. 抽象类：方法只有声明没有实现时，该方法就是抽象方法，抽象方法必须在抽象类中；
  2. 抽象类不能被实例化，因为调用抽象方法没有意义；
  3. 抽象类必须由子类覆盖抽象类方法，否则，子类还是抽象类；
  • 抽象类是构造函数吗？

　　　　

是，用于给子类对象初始化；

  • 抽象类可以不定义抽象方法？

　　　　

可以，但是少见，通常类中有很多方法，但是却没有内容；

  • 抽象类不能和哪些关键字？

　　　　

private、final、static

  • 抽象类和一般类异同点：

　　　

相同点：
抽象类和一般类都是用来描述事物的，都在内部定义了成员；
不同点：

  1. 一般类有足够信息描述事物；
  2. 一般类不能定义抽象方法；
  3. 一般类可以被实例化；
  • 抽象类是一个父类吗？　　　　

对.

接口

interface() 当抽象类中方法都是抽象时，这时可以将该抽象类用接口、

　　　

定义接口使用的关键字不是class，是interface

  • 对于接口常见的成员：
  1. 全局变量(public static final)
  2. 抽象方法(public abstract)

由此得出结论，接口成员都是公共的权限

  • 实现

类与类之间是继承关系;类与接口之间是实现关系；

接口不可以实例化，只能由实现了接口的子类并覆盖了接口中所有抽象方法后，才可以实例化；

　　　　　　

在Java中不直接支持多继承，因为会调用不确定性，所以改良多实现

　　　　　　一个类中可以实现多接口

class　　Test   implements　　A,Z 　　//多实现
  • 细节：
  • 一个类在继承另一个类的同时，还可以实现多个接口
  • 接口出现避免了单继承的局限性
  • 接口与接口之间是继承关系，而且接口可以多继承；
  • 接口的特点

是对外暴露的规则，是程序的功能拓展，可以用来多实现；　　　　　　　　　

类与接口之间是实现规则，类继承的同时可以实现多个接口，降低耦合性

  • 接口与抽象类区别：

　　　　　　

相同点：都是不断向上抽取而来；
不同点:

  1. 抽象类需要被继承，接口需要被实现；
  2. 抽象类中可以定义抽象方法和非抽象方法，接口中只可以定义抽象方法；

多态

  • 定义

某一类事物的多种存在形态；

  • 对象的多态性

一个对象对应着不同类型；

多态在代码中体现，父类或接口的引用指向其子类的对象；

  • 多态的好处

提高了代码扩展性，前期定义的代码，可以使用后期的内容；

  • 多态弊端

前期定义的内容不能调用后期子类特有内容；

  • 多态前提
  1. 必须由关心：继承，实现；
  2. 必须要有覆盖；
  • 多态转型
  1. 自动类型提升，但是特有功能无法访问；作用就是限制对特有功能访问；
  2. 向下转型的目的是为了使用子类中的特有语法；
  • 类型转换异常

注意：对于转型，自始至终都是子类对象在做着类型变化；

多态成员：

  1. 成员变量；
  2. 成员函数；
  3. 静态函数；
  • 多态成员变量
  1. 编译时，参考引用型变量所属类中是否有调用的成员变量；有，编译通过，没有，编译失败；
  2. 运行时，参考引用型变量所属类中是否有调用的成员变量；并运行该所属类中的成员变量；
  • 多态成员函数
  1. 参考引用型变量所属类中是否有调用的成员函数，有，编译通过；
  2. 运行时，参考的是对象所属类中是否有调用的成员函数；
  • 静态函数：谁调用显示谁；

其实对静态方法，直接用类名调用即可；

内部类：类定义在类中

  • 访问特点：内部类可以直接访问外部类中成员，包括私有成员；

外部类访问内部类中成员，必须建立内部类对象；

　　　　

一般用于类的设计
分析事物时，发现事物描述中还有事物；

  • 内部类——修饰符
  1. 如果内部类是静态的，相当于一个外部类；
  2. 如果内部类是静态的，成员是静态的；
  3. 如果内部类中定义了静态成员，这个类也是静态类；
  • 为什么内部类能直接访问外部类成员？

　　　　　　

因为内部类持有外部类引用；

  • 内部类可以放在局部位置上，只能访问局部被final修饰的局部变量；

  • 匿名内部类：就是内部类简写格式：必须有前提，内部类必须继承或实现一个外部类或接口；

其实就是一个匿名子类对象；

//格式：new　父类　or    接口（）{子类内容}





















































以上是关于Java语言-----封装继承抽象多态接口的主要内容，如果未能解决你的问题，请参考以下文章

Java语言简介基础组成封装继承多态抽象类内部类接口

java 面向对象三大特性（封装，继承，多态）以及抽象接口的介绍

JAVA 特征以及基本类抽象类接口

阶段1 语言基础+高级_1-3-Java语言高级_02-继承与多态_第2节 抽象类_9_接口的私有方法定义

用Java实现图书管理系统（类，抽象类，封装，继承，多态，接口，顺序表）

用Java实现 图书管理系统 使用类，抽象类，封装，继承，多态，接口等知识点