1. Toy模板网首页
  2. > Toy博客

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

10月前 作者：coleak 分类：Toy博客 阅读(44) 违法举报

这篇具有很好参考价值的文章主要介绍了【java】面向对象的编程基础。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

面向对象的编程基础

定义

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("我是构造方法");
        }
    }

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

类的封装

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

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
睡觉文章来源地址https://www.toymoban.com/news/detail-414749.html

到了这里，关于【java】面向对象的编程基础的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【Java零基础入门篇】第 ③ 期 - 面向对象编程（一）

    【Java零基础入门篇】第 ③ 期 - 面向对象编程（一）

    博主：命运之光 专栏：Java零基础入门 理解面向对象三大主要特征； 掌握类与对象的区别与使用； 掌握类中构造方法以及构造方法重载的概念及使用； 掌握包的定义、包的作用等； 掌握方法的参数传递规则。 方法的定义 🍓🍓方法在很多地方被称为 函数 （在Java中英文单

    2024年02月04日
    浏览(55)
  • 【Java零基础入门篇】第 ③ 期 - 面向对象编程（二）

    【Java零基础入门篇】第 ③ 期 - 面向对象编程（二）

    博主：命运之光 专栏：Java零基础入门 学习目标 理解面向对象三大主要特征； 掌握类与对象的区别与使用； 掌握类中构造方法以及构造方法重载的概念及使用； 掌握包的定义、包的作用等； 掌握方法的参数传递规则。 什么是封装？ 本意是把物体打包装到箱子里，然后封起

    2024年02月04日
    浏览(56)
  • 【Java基础教程】特别篇：面向对象合辑——掀开Java 的面向对象盖章时代，一起来发现OOP的编程秘密！~

    【Java基础教程】特别篇：面向对象合辑——掀开Java 的面向对象盖章时代，一起来发现OOP的编程秘密！~

    面向对象编程(Object-Oriented Programming, OOP)是一种广泛应用于软件开发的编程范式 。Java是一种面向对象的编程语言，它提供了丰富的工具和特性来支持面向对象编程。本文将详细介绍Java面向对象的全部知识。 我们可以把一个Java类想象成是一个蓝图或者模具，用来创建对象。就

    2024年02月17日
    浏览(46)

  • Java 学习路线：基础知识、数据类型、条件语句、函数、循环、异常处理、数据结构、面向对象编程、包、文件和 API

    Java 是一种由 Sun Microsystems 于 1995 年首次发布的编程语言和计算平台。Java 是一种通用的、基于类的、面向对象的编程语言，旨在减少实现依赖性。它是一个应用程序开发的计算平台。Java 快速、安全、可靠，因此在笔记本电脑、数据中心、游戏机、科学超级计算机、手机等领

    2024年03月24日
    浏览(91)

  • TypeScript类与对象：面向对象编程的基础

    TypeScript 是 JavaScript 的一个超集，它为 JavaScript 添加了静态类型、类、接口和装饰器等面向对象编程的特性，并通过编译器将 TypeScript 编译成JavaScript，可以在任何 JavaScript 环境中运行，因此成为了 JavaScript 开发中不可或缺的工具。面向对象编程是现代编程语言的基础，而 Ty

    2024年02月09日
    浏览(45)

  • 第七章 面向对象编程（基础）

    （1）类是抽象的，概念的，代表一类事物，比如人类、猫类... 即它是数据类型。 （2）对象是具体的，实际的，代表一个具体事物，即实例。 （3）类是对象的模板，对象是类的一个个体，对应一个实例。 属性是类的一个组成部分，一般是基本数据类型，也可是引用类型(对

    2024年02月06日
    浏览(86)
  • 【python】08.面向对象编程基础

    【python】08.面向对象编程基础

    活在当下的程序员应该都听过\\\"面向对象编程\\\"一词，也经常有人问能不能用一句话解释下什么是\\\"面向对象编程\\\"，我们先来看看比较正式的说法。 \\\"把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象归纳为类（class），通过类的封装（encapsulation）隐藏内部

    2024年01月20日
    浏览(50)
  • 【JAVA杂货铺】一文带你走进面向对象编程的构造方法 | Java| 面向对象编程 | (中)

    【JAVA杂货铺】一文带你走进面向对象编程的构造方法 | Java| 面向对象编程 | (中)

    🌈个人主页:  Aileen_0v0 🔥系列专栏: Java学习系列专栏 💫个人格言: \\\"没有罗马,那就自己创造罗马~\\\"   目录 回顾  构造方法  this 面试题 构造方法的类型  下节预告 代码块  之前我们学习了什么是类  什么是对象  什么是面向对象编程 定义类   构造方法 :它的方法名

    2024年02月05日
    浏览(54)

  • C++ 递归与面向对象编程基础

    递归是一种使函数调用自身的技术。这种技术提供了一种将复杂问题分解为简单问题的方法，从而更容易解决问题。 递归可能有点难以理解。理解其工作原理的最佳方法是通过实验来尝试。 将两个数字相加很容易做到，但将一系列数字相加就更复杂了。在下面的示例中，通

    2024年04月16日
    浏览(38)

  • 【C#基础】C# 面向对象编程

    序号 系列文章 5 【C#基础】C# 运算符总结 6 【C#基础】C# 常用语句讲解 7 【C#基础】C# 常用数据结构 😊大家好，我是writer桑，前面一章已经学习了 C# 中的常用数据结构，那本章就开始学习 C# 程序中面向对象编程的知识，希望看完大家能够有所收获，感谢支持！ 面向对象编程

    2024年02月04日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包