3 高级面向对象编程实例

news2024/9/26 5:18:04

高级OOP

1 继承

是一种基于已有类创建新类的机制

class 子类名 extends 父类{
    类体;
}

public class Extends_v1 {
    public static void main(String[] args) {
        Extendsclass01 ex = new Extendsclass01();
    }
}
class Baseclass01{
    public int num;

    public void setNum(int n){
        num = n;
    }
}
class Extendsclass01 extends Baseclass01{

}
  • 通过继承，子类继承了父类的除了构造方法的全部属性和方法
  • Java中只存在单继承

1.1 继承时权限的变化

  • 父类的public成员在子类中也是public
  • 父类的private成员在子类中变成不可访问权限
  • 子类新增成员方法不可访问不可访问成员，但是父类原有的方法可以访问
public class Extends_v2 {
    public static void main(String[] args) {
        Extendsclass02 ex = new Extendsclass02();
        ex.setNum(2);
        System.out.println(ex.getNum());
    }
}
class Baseclass02{
    private int num;

    public void setNum(int n){
        num = n;
    }
    public int getNum(){
        return num;
    }
}
class Extendsclass02 extends Baseclass02{

}

1.2 子类对象的构造

构造顺序：

  • 先构造父类对象

  • 再构造子类新增部分

  • 子类构造方法再调用之前，先调用父类构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nqNM5sf6-1672287375730)(C:\Users\ALANSHAO\AppData\Roaming\Typora\typora-user-images\image-20221013095907251.png)]

子类对象里包含一个父类对象，父类对象通过父类构造函数进行初始化，其它属性通过子类对象初始化

public class Extends_v3 {
    public static void main(String[] args) {
        Extendsclass03 ex = new Extendsclass03();
    }
}
class Baseclass03{
    Baseclass03(){
        System.out.println("父类构造函数");
    }
}
class Extendsclass03 extends Baseclass03{
    Extendsclass03(){
        System.out.println("子类构造函数");
    }
}

1.3 成员变量的隐藏和方法的重写

**成员变量的隐藏：**子类和父类的属性名重复，则继承自父类的属性被隐藏

**方法的重写：**子类中声明的方法，方法名、参数列表与父类中某个方法完全一致，返回值类型与父类该方法返回值类型一致或是其子类型，则父类方法被重写

public class Extends_v4 {
    public static void main(String[] args) {
        Extendsclass04 ex = new Extendsclass04();

        System.out.println(ex.num1);
        System.out.println(ex.num2);
        System.out.println(ex.getNum1());
        System.out.println(ex.getNum2());
        ex.output();
    }
}
class Baseclass04{
    public int num1 = 1;
    public int num2 = 2;

    public int getNum1(){
        return num1;
    }
    public void output(){
        System.out.println("这是父类");
    }
}
class Extendsclass04 extends Baseclass04{
    public int num1 = 3;
    public int num2 = 4;
    public int getNum2(){
        return num2;
    }
    public void output(){
        System.out.println("这是子类");
    }
}
//输出结果
3
4
1
4

1.4 super关键字

作用：

  • 调用父类构造方法，为父类构造方法传参
  • 访问父类被隐藏的属性
  • 调用父类被重写的方法
public class TestSuper {
    public static void main(String[] args) {
        Extendsclass06 ex = new Extendsclass06(1, 2);
        System.out.println(ex.num1 + " " + ex.num2);
    }
}
class Baseclass06{
    public int num1;
    public int num2;

    Baseclass06(int n1, int n2){
        num1 = n1;
        num2 = n2;
    }
}
class Extendsclass06 extends Baseclass06{
    public Extendsclass06(int n1, int n2){
        super(n1, n2);
    }
}

public class TestSuper_v2 {
    public static void main(String[] args) {
        Extendsclassv2 ex = new Extendsclassv2();
        ex.output();
    }
}
class Baseclassv2{
    public int num1 = 1;
    public int num2 = 2;
}
class Extendsclassv2 extends Baseclassv2{
    public int num1 = 3;
    public int num2 = 4;

    public void output(){
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(super.num1);
        System.out.println(super.num2);
    }
}

public class TestSuper_v3 {
    public static void main(String[] args) {
        Extendsclassv3 ex = new Extendsclassv3();
        ex.fun();
    }
}
class Baseclassv3{
    public void output(){
        System.out.println("这是父类");
    }
}
class Extendsclassv3 extends Baseclassv3{
    public void output(){
        System.out.println("这是子类");
    }
    public void fun(){
        output();
        super.output();
    }
}

1.5 final关键字

作用：

  • 类不能被继承
  • 方法不能重写
  • 属性值不能改变
  • 对于方法中的局部变量
    • 基本类型的值不能改变
    • 引用类型的指向对象不能改变

2 对象向上转型

是指父类的引用指向子类的对象

class Father{
    
}

class Son{
    
}

public class Test{
    public static void main(String[] args){
        Father f = new Son();
    }
}

特点：

  • 父类引用不可以访问子类新增的成员（属性与方法）
  • 父类引用访问父类中被隐藏属性是子类继承的属性
  • 父类引用调用被子类重写的方法时调用的是重写过的方法
public class UpCasting {
    public static void main(String[] args) {
        Father f = new Son();

        //访问子类的特有成员
        //System.out.println(f.num3);
        //System.out.println(f.fun3());

        //调用被子类覆盖的成员
        System.out.println(f.num1); 
        f.fun1();
    }
}
class Father{
    public int num1 = 1;
    public int num2 = 2;

    public void fun1(){
        System.out.println("这是父类fun1");
    }
    public void fun2(){
        System.out.println("这是父类fun2");
    }
}
class Son extends Father{
    public int num1 = 3;
    public int num3 = 4;

    public void fun1(){
        System.out.println("这是子类fun1");
    }
    public void fun3(){
        System.out.println("这是子类fun3");
    }
}

3 多态

是指同样的方法作用在不同的对象时产生的不同的效果。

多态产生的条件：

  • 继承
  • 方法重写
  • 对象向上转型
  • 动态绑定
public class Polymorpyhrism {
    public static void say(animal a){
        a.say();
    }
    public static void main(String[] args) {
        dog d = new dog();
        cat c = new cat();
        bird b = new bird();
        say(d);
        say(c);
        say(b);
    }
}
class animal{
    public void say(){
        System.out.println("AAA");
    }
}
class dog extends animal{
    public void say(){
        System.out.println("www");
    }
}
class cat extends animal{
    public void say(){
        System.out.println("mmm");
    }
}
class bird extends animal{
    public void say(){
        System.out.println("jjj");
    }
}

4 抽象方法和抽象类

抽象方法：

  • 只允许声明不允许实现的方法
  • 需要使用abstract修饰
  • 必须在抽象类中声明

抽象类：

  • 使用关键词abstract声明
  • 可以包含普通方法和抽象方法
  • 可以被继承，但是不可以用来创建对象
  • 子类必须重写全部抽象方法
public class TestAbstact {
    public static void main(String[] args) {
        //使用子类引用创建对象
        extendsAbstact ex1 = new extendsAbstact();
        //使用父类引用创建对象
        Abstactclass ex2 = new extendsAbstact();
        //使用抽象类创建对象  失败
        //Abstactclass ex3 = new Abstactclass();

        ex1.fun1();
        ex2.fun2();
        ex2.fun1();
        ex2.fun2();
    }
}
abstract class Abstactclass{
    public void fun1(){
        System.out.println("这是抽象类的普通方法");
    }
    public abstract void fun2();
}
class extendsAbstact extends Abstactclass{
    //必须重写，否则无法继承
    @Override
    public void fun2() {
        System.out.println("这是子类重写的抽象方法");
    }
}

5 接口

是一种特殊的类，只包含公共抽象方法，静态常量

interface 接口名{
    [public][static][final] 数据类型 属性名；
    [public][abstract] 返回值类型 方法名(形参列表);
}
  • 接口不能被实例化，但是可以被其他类实现
  • 一个类只能继承一个父类，但是可以实现多个接口
  • 如果一个类需要实现一个接口，那他就要实现接口的全部方法
public class TestInterface {
    public static void animalCrazy(Animal an){
        an.run();
        an.say();
    }
    public static void main(String[] args) {
        Animal dog = new dog_inter();
        Animal snake = new cat_inter();
        Animal bird = new bird_inter();
        animalCrazy(dog);
        animalCrazy(snake);
        animalCrazy(bird);
    }
}
interface Animal{
    public abstract void say();
    void run();
}
class dog_inter implements Animal{
    public void say(){
        System.out.println("汪汪汪......");
    }
    public void run(){
        System.out.println("四条腿跑");
    }
}
class cat_inter implements Animal{
    public void say(){
        System.out.println("喵喵喵......");
    }
    public void run(){
        System.out.println("被追着跑");
    }
}
class bird_inter implements Animal{
    public void say(){
        System.out.println("咕咕咕......");
    }
    public void run(){
        System.out.println("翅膀飞");
    }
}

public class TestInterface_v2 {
    public static void main(String[] args) {
        student s = new student();
        s.read();
        s.write();
    }
}
interface read1{
    void read();
}
interface write1{
    void write();
}
class student implements read1, write1{
    public void read(){
        System.out.println("学生在阅读");
    }
    public void write(){
        System.out.println("学生在写作业");
    }
}

}

public class TestInterface_v2 {
    public static void main(String[] args) {
        student s = new student();
        s.read();
        s.write();
    }
}
interface read1{
    void read();
}
interface write1{
    void write();
}
class student implements read1, write1{
    public void read(){
        System.out.println("学生在阅读");
    }
    public void write(){
        System.out.println("学生在写作业");
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/127213.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

java之线程死锁和ThreadLocal的使用

java之线程死锁和ThreadLocal的使用

线程死锁： 线程死锁是指两个或者两个以上的线程在执行过程中，由于竞争资源或者彼此通信而造成的一种阻塞的现象,若无外力的作用,它们都将无法继续执行下去。 此时应用系统就处于了死锁状态，这些永远在互相等待的线程称为死锁线程。 如下图…
阅读更多...
文本中按规则分组区段随机抽样

文本中按规则分组区段随机抽样

【问题】 This is a bit complex, and I greatly appreciate any help! I am trying to randomly sample rows from a .csv file. Essentially, I want a resulting file of unique locations (Locations are specified by Easting and Northing columns of the data file, be…
阅读更多...
ServletContext和过滤器

ServletContext和过滤器

✅作者简介：热爱国学的Java后端开发者，修心和技术同步精进。 🍎个人主页：Java Fans的博客 🍊个人信条：不迁怒，不贰过。小知识，大智慧。 💞当前专栏：JAVA开发者…
阅读更多...
BM30 二叉搜索树与双向链表

BM30 二叉搜索树与双向链表

题目 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。如下图所示： 数据范围：输入二叉树的节点数0≤n≤1000，二叉树中每个节点的值0≤val≤1000. 要求：空间复杂度O(1)（即在原树上操作&#x…
阅读更多...
低代码对比分析，从工程化上看产品的优劣

低代码对比分析，从工程化上看产品的优劣

低代码算是这几年在IT行业内越来越尖锐的讨论了，而且随着这两年大厂的大量裁员，更是亲者痛仇者快的事情，因为很多大厂发现把一些低端的研发岗位干掉了，反而整个体系在工具的辅助运转下，效率更高，执行力更优…
阅读更多...
【Python数据分析】Python模拟登录(一) requests.Session应用

【Python数据分析】Python模拟登录(一) requests.Session应用

最近由于某些原因，需要用到Python模拟登录网站，但是以前对这块并不了解，而且目标网站的登录方法较为复杂， 所以一下卡在这里了，于是我决定从简单的模拟开始，逐渐深入地研究下这块。 注：本文仅为…
阅读更多...
Python学习基础笔记五十九——封装和@property

Python学习基础笔记五十九——封装和@property

1、私有属性的一个用法： class Room:def __init__(self, name, length, width):self.name nameself.__length lengthself.__width widthdef area(self):return self.__length * self.__widthwei Room(Wei, 2, 1) print(wei.area()) 2、getter和setter&#xf…
阅读更多...
Hi3861鸿蒙物联网项目实战：智能照明灯

Hi3861鸿蒙物联网项目实战：智能照明灯

华清远见FS-Hi3861开发套件，支持HarmonyOS 3.0系统。开发板主控Hi3861芯片内置WiFi功能，开发板板载资源丰富，包括传感器、执行器、NFC、显示屏等，同时还配套丰富的拓展模块。开发板配套丰富的学习资料，包括全套开发教程…
阅读更多...
第十篇 1+X考证 Web前端测试题（新）

第十篇 1+X考证 Web前端测试题（新）

单选题 1、关于HTML和CSS以下说法错误的是（ D ） A、HTML标签中属性的值一定要用双引号或单引号括起来B、HTML空元素要有结束的标签或于开始的标签后加上"/"C、结构与样式完全分离时，结构代码中不涉及任何的样式元素，如f…
阅读更多...
Qt之软键盘的实现

Qt之软键盘的实现

文章目录前言一、基于中文汉字数据库1、核心代码2、效果二、基于谷歌拼音输入引擎1、核心代码2、效果前言 Qt5.8版本开始推出了基于QML实现的软键盘功能，在此之前，并没有官方版本的软键盘。本篇主要介绍Qt实现软键盘的两种方案，一种基于中文汉…
阅读更多...
[python][GUI]pyside6

[python][GUI]pyside6

------------------------------------------------------------------------------------------------------------------ #非常好资料和教程： 1. Module Index - Qt for Python 2. muziing/PySide6-Code-Tutorial: 可能是最好的PySide6中文教程！用代…
阅读更多...
Spring boot 日志直接推送到elasticsearch上

Spring boot 日志直接推送到elasticsearch上

Spring boot 日志直接推送到elasticsearch前言核心依赖elasticsearch配置文件1.url格式如下2.index索引前缀 "xxx"3.maxMessageSize参数数据内容最大值，本文未使用（默认值-1全部数据接收）如下4.BasicAuthentication.java 重写该类用…
阅读更多...
详解opencv库函数ellipse()

详解opencv库函数ellipse()

opencv库函数ellipse()函数可以画扇形，也可以画椭圆。画扇形时只需要将椭圆的长短轴长度设为相同并给定扇形的圆心角即可。 # 参数 1.目标图片 2.椭圆圆心 3.长短轴长度 4.偏转角度 5.圆弧起始角度 6.终止角度 7.颜色 8.是否填充 cv2.ellipse(img_p, (500, 2…
阅读更多...
[python] PyMouse、PyKeyboard用python操作鼠标和键盘

[python] PyMouse、PyKeyboard用python操作鼠标和键盘

1、PyUserInput 简介 PyUserInput是一个使用python的跨平台的操作鼠标和键盘的模块，非常方便使用。支持的平台及依赖如下： Linux - XlibMac - Quartz, AppKitWindows - pywin32, pyHook 支持python版本：我用的是3.6.7 2、安装 直接源码安装…
阅读更多...
越南猫年来袭！2023Lazada年货节热销品趋势

越南猫年来袭！2023Lazada年货节热销品趋势

距离2023年春节倒计时23天！大家是否对春节假期已经满怀期待了？越南人也和我们一样正期盼着新年到来，越南所有的传统节日都是按照农历来算的，其中春节也是越南重大的节日。春节将至，提前置办年货成了越南人和华人必不可…
阅读更多...
MySQL 表的增删改查（进阶篇②）· 联合查询 内连接 外连接 · 自连接 · 子查询 exists · 合并查询 union

MySQL 表的增删改查（进阶篇②）· 联合查询 内连接 外连接 · 自连接 · 子查询 exists · 合并查询 union

接进阶篇①，我们继续学习。 一、联合查询1.1 内连接1.2 外连接1.3 内连接和左右外连接的区别二、自连接三、子查询3.1 单行子查询3.2 多行子查询使用 in 范围匹配多行另一种写法 exists两种写法的区别3.3 在 from 子句中使用子查询四、合并查询unionunion all一、联…
阅读更多...
随谈_前端与后端

随谈_前端与后端

文章目录一、前言二、前后端分别是什么？2.1. 前端（front end）2.2. 后端（back end）一、前言 最近在学习Vue，打算边学边用，开发一个网页系统。 Vue的话，网上介绍很多，简单…
阅读更多...
容器安全的三大挑战

容器安全的三大挑战

容器凭借其经济高效的优势改变了应用程序的交付方式，随着容器的普遍使用，管理应用程序基础设施的 IT 劳动力和资源也显著减少。然而，在保护容器和容器化生态系统时，软件团队遇到了许多障碍。尤其是习惯于更传统的网络安全流程和策…
阅读更多...
MYSQL学习之路

MYSQL学习之路

MYSQL架构示意图 MYSQL8.0开始移除了查询缓存这个模块； 查询缓存：适合读多写少的任务； 建议：将 have_query_cache 设置为No，在需要使用查询缓存的语句上显式声明； select SQL_CACHE * from test;WAL(Write …
阅读更多...
mysql sql优化、查看索引、创建索引

mysql sql优化、查看索引、创建索引

1.索引遵循原则 仅在被频繁检索的字段上创建索引。针对大数据量的表创建索引，而不是针对只有少量数据的表创建索引。通常来说，经常查询的记录数目少于表中总记录数据的 15% 时，可以创建索引。这个比例并不绝对，它与全表扫描速度成…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023