【java】面向对象的编程基础

news2025/1/31 8:07:38

文章目录

  • 面向对象的编程基础
    • 定义
    • 方法重载
    • 执行顺序
    • 静态变量和方法
    • 加载顺序
    • 包和访问控制
    • 类的封装
    • object类
    • 方法重写
    • 抽象类
    • 接口
    • 枚举类

面向对象的编程基础

定义

public class person  {
String name;
int age;
char sex;
person(String name,int age,char sex)
{
    this.age=age;
    this.name=name;
    this.sex=sex;
}
person()
{}
}

public class Main {
    public static void main(String[] args) {
        person p1 = new person();   //这两个变量分别引用的是不同的两个对象
        person p2 = new person();
        person p3=p1;
        System.out.println(p1 == p3);
        System.out.println(p1 == p2);   //如果两个变量存放的是不同对象的引用，那么肯定就是不一样的了
    }
}

true
false

public class Main {
    public static void main(String[] args) {
        person p1 = new person();   //这两个变量分别引用的是不同的两个对象
        p1.setName("coleak");
        System.out.println(p1.getName());
    }
}

public class person  {
String name;
int age;
char sex;
person(String name,int age,char sex)
{
    this.age=age;
    this.name=name;
    this.sex=sex;
}
person()
{}
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

这里输入set和get可以自动将函数补全，传参初始化在构造属性之后

方法重载

int sum(int a, int b){
    return a + b;
}

double sum(double a, double b){    //为了支持小数加法，我们可以进行一次重载
    return a + b;
}

执行顺序

public class Main {
    public static void main(String[] args) {
        person p1 = new person("coleak",19,'n');
        System.out.println(p1.name);
    }
}

public class person  {
String name="cc";
int age=1;
char sex='n';
person(String name,int age,char sex)
{
    System.out.println(this.name);
    this.age=age;
    this.name=name;
    this.sex=sex;
}
{
    System.out.println(this.name);
    this.name="ccccc";
}
}

cc
ccccc
coleak

这里说明先构造属性，再执行代码块，再初始化

静态变量和方法

public class Main {
    public static void main(String[] args) {
        person p1 = new person("coleak",19,'n');
        for(int i=0;i<3;i++) {
            person p = new person();
        }
        System.out.println(person.num);
        person.test();
    }
}

public class person  {
String name="cc";
int age=1;
char sex='n';
static int num=0;
person()
{
    num++;
}
person(String name,int age,char sex)
{
    this.age=age;
    this.name=name;
    this.sex=sex;
    num++;
}
static void test()
{
    System.out.println(num);
    //System.out.println(age);不能调用非static的成员变量和方法
}
static {
    System.out.println("静态代码块");
}
}

静态代码块
4
4

加载顺序

public class person {
        String name = test();  
    	int age;
        String sex;

        {
            System.out.println("我是普通代码块");
        }

        person(){
            System.out.println("我是构造方法");
        }

        String test(){
            System.out.println("我是成员变量初始化");
            return "小明";
        }

        static String info = init();

        static {
            System.out.println("我是静态代码块");
        }

        static String init(){
            System.out.println("我是静态变量初始化");
            return "test";
        }
    }

public class Main {
    public static void main(String[] args) {
        person p=new person();
    }
}

我是静态变量初始化
我是静态代码块
我是成员变量初始化
我是普通代码块
我是构造方法

包和访问控制

package com.test;
import com.test.entity.*;

public class Main {
    public static void main(String[] args) {
        person p=new person();
        p.name="coleak";
        java.lang.System.out.println(p.name);
    }
}

package com.test.entity;
public class person {
        public String name;  //这里我们用test方法的返回值作为变量的初始值，便于观察
        int age;
        String sex;
        public person(){
            System.out.println("我是构造方法");
        }
    }

在这里插入图片描述

类的封装

快速构造，点击生成，构造函数，全选即可。

package com.test;
import com.test.entity.*;

public class Main {
    public static void main(String[] args) {
        person p=new person("coleak",18,"nan");
        java.lang.System.out.println(p.getName());
        p.setName("xax");
        System.out.println(p.getName());
        p.setName("cc");
        System.out.println(p.getName());
    }
}

package com.test.entity;
public class person {
        private String name;  //这里我们用test方法的返回值作为变量的初始值，便于观察
        private int age;
        private String sex;
        public person()
        {
            System.out.println("我是构造方法");
        }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    public void setName(String name) {
        if (name.contains("a"))  return;
        this.name = name;
    }

    public String getSex() {
        return sex;
    }
    public person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}

coleak
coleak
cc

类的继承

package com.test.entity;

public class student extends worker{
    public student(String name, int age, String sex) {
        super(name, age, sex);
    }

    public void stu(){
        System.out.println("stu");
    }
}


package com.test.entity;
public class person {
         protected String name;  //这里我们用test方法的返回值作为变量的初始值，便于观察
         int age;
         String sex;
       public void per()
         {
             System.out.println("person");
         }
    person(){}
    public person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}

package com.test.entity;

public class worker extends person {
    public worker(String name, int age, String sex) {
        super(name, age, sex);
    }
    public void wor()
 {
     System.out.println("worker");
 }
    public worker(){}
}


package com.test;
import com.test.entity.*;
public class Main {
    public static void main(String[] args) {
        student s1=new student("coleak",19,"nan");
        s1.wor();
        s1.stu();
        s1.per();
        person w1=new worker();//以父之名,只能访问父类的内容
        w1.per();
        worker w2=(worker) w1;//强制类型转换,原本就是worker的情况
        w2.wor();
        w2.per();
        if(w1 instanceof worker&&w1 instanceof person)//对应类型或者是其继承类
        {
            System.out.println("YES");
        }
    }
}

worker
stu
person
person
worker
person
YES

与父类同名属性，就近原则使用本身的属性值。

访问父类时加上super.name

object类

package com.test;
import com.test.entity.*;
public class Main {
    public static void main(String[] args) {
        student s1=new student("coleak",19,"nan");
        student s2=s1;
        student s3=new student("coleak",19,"nan");
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s1);//默认调用tostring
    }
}

true
false
com.test.entity.student@3ac3fd8b

方法重写

final 无法重写，无法重新赋值，无法继承

子类无法低于父类的可见性

package com.test.entity;
public class person {
    protected String name;  //这里我们用test方法的返回值作为变量的初始值，便于观察
    int age;
    String sex;

    person() {
    }

    ;

    public person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof person) {     //只有是当前类型的对象，才能进行比较，要是都不是这个类型还比什么
            person person = (person) obj;   //先转换为当前类型，接着我们对三个属性挨个进行比较
            return this.name.equals(person.name) &&    //字符串内容的比较，不能使用==，必须使用equals方法
                    this.age == person.age &&       //基本类型的比较跟之前一样，直接==
                    this.sex.equals(person.sex);
        }
        return false;
    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

package com.test;
import com.test.entity.*;
public class Main {
    public static void main(String[] args) {
        student s1=new student("coleak",19,"nan");
        student s2=s1;
        student s3=new student("coleak",19,"nan");
        System.out.println(s1.equals(s3));//调用重写后的函数,实际对象是student
        System.out.println(s1);
    }
}

true
person{name=‘coleak’, age=19, sex=‘nan’}

抽象类

子类如果不是抽象类则不实现父类的抽象方法会报错

无法直接调用抽象类的实例方法去构造对象

package com.test.entity;
public abstract class person {
    protected String name;  //这里我们用test方法的返回值作为变量的初始值，便于观察
    int age;
    String sex;
    public person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    protected abstract void eaxm();
}

package com.test.entity;

public class student extends worker{
    public student(String name, int age, String sex) {
        super(name, age, sex);
    }

    @Override
    public void learn() {
        System.out.println("学生学习");
    }
    public void stu(){
        System.out.println("stu");
    }
}

package com.test.entity;

public abstract class worker extends person {
    public worker(String name, int age, String sex) {
        super(name, age, sex);
    }

    @Override
    protected void eaxm() {

    }
    protected abstract void learn();
}

package com.test;
import com.test.entity.*;
public class Main {
    public static void main(String[] args) {
        student s1=new student("coleak",19,"nan");
        s1.learn();
    }
}

接口

继承只能单继承，但是可以连接多个接口

接口可以继承，且继承父类的全部方法，因此子接口被引用时，类需要实现其父接口的所有方法

package com.test;
import com.test.entity.*;
public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Study s1=new student("coleak",19,"nan");
        s1.study();
        student s2=(student) s1;
        s2.test();
        s2.test2();
        System.out.println(Study.a);
        System.out.println(s1.a);
        System.out.println(s2.a);
        System.out.println(student.a);
        //s1.test2();报错，只能使用接口内定义的方法
        student clone= (student) s2.clone();
        System.out.println(clone==s2);
    }
}

package com.test.entity;

public class student extends worker implements Study,Cloneable{
    public student(String name, int age, String sex) {
        super(name, age, sex);
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public void study() {
        System.out.println("stu");
    }
    public void test2()
    {
        System.out.println("test2");
    }
}

package com.test.entity;
public interface Study {
    void study();
    //设置默认实现,子类可以不重写
    default void test()
    {
        System.out.println("默认实现");
    }
     public static final int a=10;//默认就是这个
}

stu
默认实现
test2
10
10
10
10
false

枚举类

package com.test.entity;

public class student {
    private Status status;

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }
}

package com.test.entity;
public enum Status {
        RUNNING("睡觉"), STUDY("学习"), SLEEP("睡觉");   //无参构造方法被覆盖，创建枚举需要添加参数（本质就是调用的构造方法）

        private final String name;    //枚举的成员变量
        Status(String name){    //覆盖原有构造方法（默认private，只能内部使用！）
                this.name = name;
        }

        public String getName() {   //获取封装的成员变量
                return name;
        }
}

package com.test.entity;
public class Main {
    public static void main(String[] args) {
    student s1=new student();
    s1.setStatus(Status.SLEEP);
        System.out.println(s1.getStatus().name());
        System.out.println(s1.getStatus().getName());
//        System.out.println(s1.);
    }
}

SLEEP
睡觉

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

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

相关文章

【华为OD机试】1043 - 从单向链表中删除指定值的节点

【华为OD机试】1043 - 从单向链表中删除指定值的节点

文章目录一、题目&#x1f538;题目描述&#x1f538;输入输出&#x1f538;样例1&#x1f538;样例2二、代码参考作者&#xff1a;KJ.JK&#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &am…
阅读更多...
计算机网络笔记（横向）

计算机网络笔记（横向）

该笔记也是我考研期间做的整理。一般网上的笔记是按照章节纪录的&#xff0c;我是按照知识点分类纪录的&#xff0c;大纲如下&#xff1a; 文章目录1. 各报文1.1 各报文头部详解1.2 相关口诀2. 各协议2.1 各应用层协议使用的传输层协议与端口2.2 各协议的过程2.2.1 数据链路层的…
阅读更多...
零死角玩转stm32中级篇2-IIC总线

零死角玩转stm32中级篇2-IIC总线

本篇博文目录:一.IIC基础知识1.什么是IIC总线2.IIC总线和串口有什么区别3.IIC总线是怎么实现多机通信4.仲裁是什么5.如果当前有一个从机进行了IIC通信又来了一个优先级高的从机&#xff0c;这时会打断前一个通信吗?6.IIC是怎么保证地址的唯一性7.在IIC总线协议中&#xff0c;规…
阅读更多...
走进小程序【六】微信小程序架构之【视图层】万字详解

走进小程序【六】微信小程序架构之【视图层】万字详解

文章目录&#x1f31f;前言&#x1f31f;小程序架构&#x1f31f;视图层 View&#x1f31f;WXML&#x1f31f;数据绑定&#x1f31f;列表渲染&#x1f31f;条件渲染&#x1f31f;模板&#x1f31f;WXSS&#x1f31f;尺寸单位&#x1f31f;样式导入&#x1f31f;内联样式&#x…
阅读更多...
VIM 编辑器使用教程

VIM 编辑器使用教程

我们如果要在终端模式下进行文本编辑或者修改文件就可以使用 VI/VIM 编辑器&#xff0c;Ubuntu 自带了 VI 编辑器&#xff0c;但是 VI 编辑器对于习惯了 Windows 下进行开发的人来说不方便&#xff0c;比如竟然 不能使用键盘上的上下左右键调整光标位置。因此我推荐大家使用 V…
阅读更多...
PADS-按键、蜂鸣器、继电器PCB封装设计

PADS-按键、蜂鸣器、继电器PCB封装设计

1 按键PCB封装设计 1.1 查看元件手册, 得知焊盘尺寸&#xff0c;同时需要观察按键&#xff0c;用丝印来进行表示。 1.2 进入PADS-Layout 无模命令UMM G0.254 GD0.254进行设计 放置一个表贴端点&#xff0c;更改矩形尺寸&#xff0c;同时计算与原点的距离&#xff0c;这里我们按…
阅读更多...
流量整形（GTS和LR）

流量整形（GTS和LR）

Generic Traffic Shaping通用流量整形 通用流量整形（简称GTS）可以对不规则或不符合预定流量特性的流量进行整形，以保证网络上下游之间的带宽匹配，避免拥塞发生。 GTS与CAR一样，都采用了令牌桶技术来控制流量。GTS与CAR的主要区别在于：利用CAR进行报文流量控制时，…
阅读更多...
DFIG控制7：不平衡电网下的转子侧控制

DFIG控制7：不平衡电网下的转子侧控制

DFIG控制7&#xff1a;不平衡电网下的转子侧控制。主要是加入了转子侧的电流负序分量控制器。 本文基于教程的第7部分&#xff1a; DFIM Tutorial 7 - Asymmetrical Voltage Dips Analysis in DFIG based Wind Turbines 控制策略简介 来自&#xff1a; H. Abu-Rub, M. Malin…
阅读更多...
【Java实现】约瑟夫问题的Java代码实现

【Java实现】约瑟夫问题的Java代码实现

约瑟夫问题&#xff08;Josephus Problem&#xff09;是一个经典的数学问题&#xff0c;描述了一群人围成一圈报数&#xff0c;每报到第几个人就会被杀死&#xff0c;直到最后只剩下一个人。 1&#xff09;设编号为 1&#xff0c;2&#xff0c;3 ... n 的 n 个人围坐一圈。 2&…
阅读更多...
MySQL之数据类型

MySQL之数据类型

目录 一 数值类型 1 int类型&#xff0c;以tinyint为例 范围&#xff1a; 越界问题&#xff1a; 验证&#xff1a; 2 bit&#xff08;位&#xff09; 应用&#xff1a; 显示问题&#xff1a; 3 小数 1 float[(M,D)] [unsigned] 范围&#xff1a; 2 decimal 精度问…
阅读更多...
TCP分包和粘包

TCP分包和粘包

文章目录TCP分包和粘包TCP分包TCP 粘包分包和粘包解决方案&#xff1a;TCP分包和粘包 TCP分包 场景&#xff1a;发送方发送字符串”helloworld”&#xff0c;接收方却分别接收到了两个数据包&#xff1a;字符串”hello”和”world”发送端发送了数量较多的数据&#xff0c;接…
阅读更多...
神策数据荣获“MarTech 领域最具商业合作价值企业”称号

神策数据荣获“MarTech 领域最具商业合作价值企业”称号

近日&#xff0c;数据猿 2023 年度 3 月“企业盘点”活动落下帷幕&#xff0c;《2023 中国 MarTech 领域最具商业合作价值企业盘点》正式对外发布。神策数据依托在 MarTech 领域的专业度与知名度&#xff0c;被评为“MarTech 领域最具商业合作价值企业”。本次盘点活动从企业相…
阅读更多...
pytorch 线性回归总结

pytorch 线性回归总结

测试1(y3∗x1−4∗x2y3*x_{1}-4*x_{2}y3∗x1​−4∗x2​),lr1e-2 %matplotlib inline import torch import numpy as np torch.manual_seed(1) from torch.nn import Linear from torch.autograd import Variable import torch.nn as nn import random np.random.seed(1) rand…
阅读更多...
代码随想录-68-669. 修剪二叉搜索树

代码随想录-68-669. 修剪二叉搜索树

目录前言题目1.按照二叉搜索树特性遍历整棵二叉搜索树&#xff0c;2. 本题思路分析&#xff1a;3. 算法实现4. 算法坑点前言 我在刷卡哥的“代码随想录”&#xff0c;自己的总结笔记均会放在“算法刷题-代码随想录”该专栏下。 代码随想录此题链接 题目 1.按照二叉搜索树特性…
阅读更多...
JavaWeb开发 —— JavaScript（JS）

JavaWeb开发 —— JavaScript（JS）

目录 一、什么是JavaScript &#xff1f; 二、引入方式 三、基础语法 1. 书写语法 2. 输出语句 3. 变量 4. 数据类型 5. 运算符 6. 类型转换 四、函数 五、对象 1. Array数组 2. String 字符串 3. JSON 4. BOM 5. DOM 六、时间监听 一、什么是JavaSc…
阅读更多...
MAE论文笔记+Pytroch实现

MAE论文笔记+Pytroch实现

Masked Autoencoders Are Scalable Vision Learners&#xff0c; 2021 近期在梳理Transformer在CV领域的相关论文&#xff0c;落脚点在于如何去使用Pytroch实现如ViT和MAE等。通过阅读源码&#xff0c;发现不少论文的源码都直接调用timm来实现ViT。故在此需要简单介绍一下timm…
阅读更多...
Vulnhub_Pylington

Vulnhub_Pylington

目录 一、信息收集 &#xff08;一&#xff09;端口服务探测 &#xff08;二&#xff09;目录扫描 二、漏洞挖掘 &#xff08;一&#xff09;robots敏感信息泄露 &#xff08;二&#xff09;python IDE沙箱绕过RCE 1. python敏感函数沙盒绕过 2. exec(__import_…
阅读更多...
2.3 连续性随机变量

2.3 连续性随机变量

思维导图&#xff1a; 学习目标&#xff1a; 我会按照以下步骤学习连续型随机变量&#xff1a; 复习概率论的基础知识&#xff0c;包括概率、期望、方差等概念和公式&#xff0c;以及离散型随机变量的概率分布函数和概率质量函数的概念和性质。 学习连续型随机变量的概念和性…
阅读更多...
在线文章生成-自动文章生成

在线文章生成-自动文章生成

文章生成软件 文章生成软件是一种能够自动生成文章的创作工具&#xff0c;可以大幅提高创作效率并节省创作成本。使用文章生成软件可以有效缩短文章的创作时间&#xff0c;尤其是在大批量的文章生产和时间紧迫的情况下&#xff0c;有着重要的作用。以下是文章生成软件可以为我…
阅读更多...
初识C++之位图与布隆过滤器

初识C++之位图与布隆过滤器

一、位图 1.位图的概念 在了解位图前&#xff0c;先来看这么一道题&#xff1a; 假设给你40亿个没有排序的不重复的无符号整数。再给你一个无符号整数&#xff0c;让你判断这个整数是否在这40亿个数之中。 对于这道题&#xff0c;一般情况下的解法有很多&#xff0c;例如二…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023