备案控制台
开发者社区 开发与运维 文章 正文

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

2023-08-22 32
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【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("我是构造方法");
        }
    }

类的封装

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

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.);
    }
}
文章标签：
Java
数据安全/隐私保护
关键词：
Java编程
Java面向对象
coleak
目录
相关文章
Byyyi
|
6天前
|
存储 安全 Java
Java面向对象最新超详细总结版！
Java面向对象最新超详细总结版！
Byyyi
25 7
Java面向对象最新超详细总结版！
技术混子
|
1天前
|
安全 Java
深入理解Java并发编程：线程安全与性能优化
【5月更文挑战第11天】在Java并发编程中，线程安全和性能优化是两个重要的主题。本文将深入探讨这两个方面，包括线程安全的基本概念，如何实现线程安全，以及如何在保证线程安全的同时进行性能优化。我们将通过实例和代码片段来说明这些概念和技术。
技术混子
2 0
历年考试不作弊
|
1天前
|
Java 调度
Java并发编程：深入理解线程池
【5月更文挑战第11天】本文将深入探讨Java中的线程池，包括其基本概念、工作原理以及如何使用。我们将通过实例来解释线程池的优点，如提高性能和资源利用率，以及如何避免常见的并发问题。我们还将讨论Java中线程池的实现，包括Executor框架和ThreadPoolExecutor类，并展示如何创建和管理线程池。最后，我们将讨论线程池的一些高级特性，如任务调度、线程优先级和异常处理。
历年考试不作弊
6 0
Huazie
|
2天前
|
缓存 Java 数据库
Java并发编程学习11-任务执行演示
【5月更文挑战第4天】本篇将结合任务执行和 Executor 框架的基础知识，演示一些不同版本的任务执行Demo，并且每个版本都实现了不同程度的并发性。
Huazie
20 4
Java并发编程学习11-任务执行演示
菜菜的后端私房菜
|
3天前
|
存储 安全 Java
12条通用编程原则✨全面提升Java编码规范性、可读性及性能表现
12条通用编程原则✨全面提升Java编码规范性、可读性及性能表现
菜菜的后端私房菜
26 11
菜菜的后端私房菜
|
3天前
|
缓存 Java 程序员
关于创建、销毁对象⭐Java程序员需要掌握的8个编程好习惯
关于创建、销毁对象⭐Java程序员需要掌握的8个编程好习惯
菜菜的后端私房菜
19 5
关于创建、销毁对象⭐Java程序员需要掌握的8个编程好习惯
toKeep
|
3天前
|
Java
java面向对象——包+继承+多态（一）-2
java面向对象——包+继承+多态（一）
toKeep
16 3
toKeep
|
3天前
|
SQL Java 编译器
java面向对象——包+继承+多态（一）-1
java面向对象——包+继承+多态（一）
toKeep
16 2
shuj
|
3天前
|
缓存 Java 数据库
Java并发编程中的锁优化策略
【5月更文挑战第9天】 在高负载的多线程应用中，Java并发编程的高效性至关重要。本文将探讨几种常见的锁优化技术，旨在提高Java应用程序在并发环境下的性能。我们将从基本的synchronized关键字开始，逐步深入到更高效的Lock接口实现，以及Java 6引入的java.util.concurrent包中的高级工具类。文中还会介绍读写锁（ReadWriteLock）的概念和实现原理，并通过对比分析各自的优势和适用场景，为开发者提供实用的锁优化策略。
shuj
4 0
然然学长
|
4天前
|
JavaScript 小程序 Java
基于java的少儿编程网上报名系统
基于java的少儿编程网上报名系统
然然学长
11 2

热门文章

最新文章

  • 1
    Java工程师该如何编写高效代码？
  • 2
    报错：java: 不兼容的类型: java.lang.String无法转换为int解决办法
  • 3
    Java已五年1—二本物理到前端实习生到Java程序员「回忆贴」
  • 4
    java的定时器详解
  • 5
    java管理hdfs文件的常用类小结
  • 6
    如何在Ubuntu 11.10下安装Java
  • 7
    Java反射机制总结（实例分析）（一）
  • 8
    深入探索Java对象的序列化
  • 9
    java接口与抽象类的区别
  • 10
    Java中REST API使用示例——基于云平台+云服务打造自己的在线翻译工具
  • 1
    [Java基础]——类的生命周期
    16
  • 2
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    28
  • 3
    【java进阶】Java中线程的实现方式
    23
  • 4
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    20
  • 5
    [java进阶]——方法引用改写Lambda表达式
    35
  • 6
    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
    127
  • 7
    java base64转doc文件
    36
  • 8
    [JavaWeb]——过滤器filter与拦截器Interceptor的使用、执行过程、区别
    47
  • 9
    Java中的异常语法知识居然这么好玩！后悔没有早点学习
    38
  • 10
    Java必刷入门递归题×5（内附详细递归解析图）
    26

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）