扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Java面向对象类和对象实例详解
  • 262

0
分享到

Java面向对象类和对象实例详解

2024-04-02 19:04:59 262人浏览 泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录1 - Java面向对象学习的三条主线2 - 面向过程与面向对象3 - 面向对象的三大特征4 - 面向对象分析方法分析问题的思路和步骤5 - 面向对象的思想概述6 - 类和对象的

1 - Java面向对象学习的三条主线

①Java类即类的成员：属性 方法 构造器 （代码块 内部类）

②面向对象的三大特征：封装性 继承性 多态性 （抽象性）

③其他关键字：this supper static final abstract interface 等

2 - 面向过程与面向对象

二者都是一种思想，面向对象是相对于面向过程而言的

　　1-面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做

　　2-面向对象：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做

　　 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象，分类，继承，聚合，多态等

3 - 面向对象的三大特征

封装(Encapsulation)

继承(Inheritance)

多态(Polymorphism)

4 - 面向对象分析方法分析问题的思路和步骤

5 - 面向对象的思想概述

1-类(Class)和对象(Object)是面向对象的核心概念：

　　①类是对一类事物的描述，是抽象的，概念上的定义

　　②对象是实际存在的该类事物的每个个体，因而也称其为实例(instance)

　　③Java世界里，"万物皆对象"

2-代码示例


// 测试类
public class PersonTest {
    public static void main(String[] args){
        // 创建Person类的对象
        Person p1 = new Person();
        // Scanner scanner = new Scanner(System.in);
        // 调用对象属性：对象.属性
        System.out.println(p1.age); // 22
        p1.name = "howie";
        p1.isMale = true;

        // 调用对象方法：对象.方法
        p1.eat();
        p1.sleep();
        p1.talk("chinese");

        // *******************
        Person p2 = new Person();
        System.out.println(p2.name); // null 说明类的初始化默认值为 null

        Person p3 = p1; // 将p1变量保存的对象空间地址值赋值给p3，导致p1和p3都指向了堆空间的同一个对象实体
        System.out.println(p3.name); // howie
    }
}
// 创建类，设计类的成员
class Person{
    // 属性
    String name;
    int age = 22;
    boolean isMale;

    // 方法
    public void eat(){
        System.out.println("人正在吃饭!");
    }
    public void sleep(){
        System.out.println("人可以睡觉！");
    }
    public void talk(String language){
        System.out.println("人可以说话，使用的是"+language);
    }
}

6 - 类和对象的创建-内存解析

1-内存解析

2-对象内存解析

7 - 类中属性的声明和使用(局部变量与成员变量的区别)

1-属性（成员变量）vs 局部变量
* 1-相同点
* 　　①定义变量的格式：数据类型 变量名 = 变量值
* 　　②先声明，后使用
* 　　③变量都有其对应的作用域
* 2-不同点
* 　　①在类中声明的位置不同
* 　　　　属性：直接定义在类的一对{}内
* 　　　　局部变量：声明在方法内，方法形参，代码块，构造器形参，构造器内部的变量
* 　　②关于权限修饰符的不同
*　　　　 属性：可以在声明属性时，指定其权限，使用权限修饰符。常用的权限修饰符：private , public , 缺省 , protected
* 　　　　目前，大家声明属性时，都使用缺省就可以(什么都不加)
* 　　　　局部变量：不可以使用权限修饰符
* 　　③默认初始化的值
* 　　　　属性：类的属性，根据其类型，都有默认初始值。
* 　　　　　　整型（byte、short、int、long）：0
*　　　　　　 浮点型（float、double）：0.0
* 　　　　　　字符型（char）：0（或'\u00000'）
* 　　　　　　布尔（boolean）：false
*
* 　　　　　　引用数据类型（类、数组、接口）：null
*　　　　 局部变量：没有默认初始化值，意味着我们在调用局部变量之前，一定要显示赋值，特别的，形参调用时赋值即可。
* 　　④在内存中加载的位置
* 　　　　属性：堆空间（非static）
* 　　　　局部变量：栈

public class test1 {
    public static void main(String[] args) {
        User u1 = new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);
        // 调用形参
        u1.talk("English");
    }
}
class User{
    // 属性（或成员变量）
    String name;
    int age;
    boolean isMale;
    public void talk(String language) {// 形参,也是局部变量
        System.out.println("我们使用"+language+"交流");
    }
    
    public void eat() {
        String foot = "米线"; // 在方法中定义的局部变量
        System.out.println("云南人喜欢吃："+foot);
    }
}

⑤内存解析需要注意两点

1-内存结构：栈(局部变量)、堆[new 出来的结构：对象（非 static成员变量）、数组]
2-变量：成员变量 vs 局部变量(方法内、方法形参、构造器内、构造器形参、代码块内)

8 - 类中方法的声明和使用

类中方法的申明和使用

　　方法：描述类应该具备的功能

　　比如 Math类：aqrt()\random()...

　　Scanner类：nexInt() ...

　　Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...

1-举例

　　public void eat() {}
　　public void sleep(int hour) {}
　　public String getName() {}
　　 public String getNation(String nation) {}

2-方法的声明

　　权限修饰符 返回值类型 方法名(形参列表) {
　　　　方法体
　　}

注意：static final abstract 来修饰的方法，后面在介绍

3-说明

　　①权限修饰符：Java规定的4种权限修饰符：private(私有的) , public , 缺省 , protected

　　　　默认方法的权限修饰符先都使用public

　　②返回类型：有返回值 vs 没有返回值

　　　　1-如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用时return关键字来返回指定类型的变量或常量

　　　　2-如果方法没有返回值，则方法声明时，使用 void来表示。通常没有返回值的方法中，就不需要使用return关键字了

　　③方法名：属于标识符，遵循标识符的规则和规范，见名知意

　　④形参列表：方法可以声明0个，1个，或多个形参...格式：数据类型1 形参1,数据类型2 形参2,...

　　⑤方法体：方法功能的体现

4-return关键字的使用

　　①使用范围：使用在方法体中

　　②作用：1.结束方法2.针对于有返回值类型的方法，使用 'return 数据'方法返回所要的数据。

　　③注意点：return关键字后面不可以声明执行语句

5-方法的使用：可以调用当前类的属性或方法

　　特殊的：方法A中调用方法A称作 递归方法

　　方法中不可以再定义方法

public class CustomerTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

// 客户类
class Customer{
    // 属性
    String name;
    int age;
    boolean isMale;
    
    // 方法
    public void eat() {
        System.out.println("客户吃饭");
    }
    
    public void sleep(int hour) {
        System.out.println("客户休息了"+hour+"个小时");
    }
    
    public String getName() {
        return name;
    }
    
    public String getNation(String nation) {
        String info = "我的国籍是"+nation;
        return info;
    }
}

练习题


public class Exer3Test {
    public static void main(String[] args) {
        Exer3Test test = new Exer3Test();
        // 第1题的测试
        // test.method();

        // 第2题的测试
//        double s = test.method();
//        System.out.println("面积为"+s);

        // 第3题的测试
        System.out.println(test.method(12,10));
    }

        // 第1问
//    public void method(){
//        for(int i = 0;i < 10;i++){
//            for(int j = 0;j < 8;j++){
//                System.out.print("* ");
//            }
//            System.out.println();
//        }
//    }
    // 第2问
//    public double method(){
//        for(int i = 0;i < 10;i++){
//            for(int j = 0;j < 8;j++){
//                System.out.print("* ");
//            }
//            System.out.println();
//        }
//        return 10*8;

    // 第3问
    public int method(int n,int m){
        for(int i = 0;i < n;i++){
            for(int j = 0;j < m;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
        return n * m;
    }
}

9 - 对象数组的使用



public class StudentTest {
    public static void main(String[] args){
        // 声明Student对象数组
        Student[] students = new Student[20];
        for(int i = 0;i < students.length;i++){
            // 给数组元素赋值
            students[i] = new Student();
            // 给Student对象的属性赋值
            students[i].number = i + 1;
            double value = Math.random();
            students[i].state = (int)(value * (6 - 1 + 1) + 1);
            double v = Math.random();
            students[i].score = (int)(v * (100 + 1) + 0);
            // System.out.print(students[i].score+"\t");
        }
        // 遍历学生数组
        for(int i = 0;i < students.length;i++){
            // System.out.println(students[i].number+","+students[i].state+","+students[i].score);
            // System.out.println(students[i].showInfo());

            // 问题1：打印出3年级(state值为3)的学生信息
            if(students[i].state == 3){
                // System.out.println(students[i].showInfo());
            }
        }
        // 问题2：使用 [冒泡排序] 按学生成绩排序，并遍历所有学生信息
        for(int i = 0;i < students.length - 1;i++){
            for(int j = 0;j < students.length - 1 - i;j++){
                if(students[j].score > students[j+1].score){
                    Student temp = students[j];
                    students[j] = students[j+1];
                    students[j+1] = temp;
                }
            }
        }
        // 遍历 排好序的 学生信息 从最高分打印
        for(int i = 0;i < students.length;i++){
            System.out.println(students[students.length - i-1].showInfo());
        }
    }
}

class Student{
    int number; // 学号
    int state; // 年级
    int score; // 成绩

    public String showInfo(){
        return "学号："+number+" "+"年级："+state+" "+"成绩："+score;
    }
}

对象数组使用示例

数组对象内存解析

10 - 理解 "万物皆对象"

11 - 匿名对象


public class PhoneTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Phone p = new Phone();
        // p = null;
        System.out.println(p);
        p.sendEmail();
        p.playGame();
        
        // 匿名对象
        // new Phone().sendEmail();
        // new Phone().playGame();
        new Phone().price = 199;
        new Phone().showPrice(); // 0.0
        
        PhoneMall mall = new PhoneMall();
        // mall.show(p);
        // 匿名对象的使用
        mall.show(new Phone());

    }
}
class PhoneMall{
    public void show(Phone phone) {
        phone.sendEmail();
        phone.playGame();
    }
}

class Phone{
    double price; // 价格
    
    public void sendEmail() {
        System.out.println("发送邮件");
    }
    public void playGame() {
        System.out.println("打游戏");
    }
    public void showPrice() {
        System.out.println("手机价格为"+price);
    }
}

匿名对象的使用

12 - 方法的封装(数组常用算法的封装)

注意两个Java文件在同级目录

①在ArrayUtils.java 文件中 创建类并分装方法

public class ArrayUtils {
    // 求数组最大值
    public int getMax(int[] array){
        int max = array[0];
        for(int i = 1;i < array.length;i++){
            if(array[i] > max){
                max = array[i];
            }
        }
        return max;
    }
    // 求数组最小值
    public int getMin(int[] array){
        int min = array[0];
        for(int i = 1;i < array.length;i++){
            if(min > array[i]){
                min = array[i];
            }
        }
        return min;
    }
    // 求数组总和
    public int getSum(int[] array){
        int sum = 0;
        for(int i = 0;i < array.length;i++){
            sum += array[i];
        }
        return sum;
    }
    // 求数组平均值
    public double getAvg(int[] array){
        return getSum(array) / array.length;
    }
    // 反转数组
    public void reverseArray(int[] array){
        for(int i = 0;i < array.length / 2;i++){
            int temp = array[i];
            array[i] = array[array.length - i - 1];
            array[array.length - i - 1] = temp;
        }
    }
    // 复制数组
    public int[] copyArray(int[] array){
        int[] newArray = new int[array.length];
        for(int i = 0;i < array.length;i++){
            newArray[i] = array[i];
        }
        return newArray;
    }
    // 数组排序
    public void sortArray(int[] array){
        
        for(int i = 0;i < array.length - 1;i++){
            for(int j = 0;j < array.length - i -1;j++){
                if(array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }
    // 遍历数组
    public void print(int[] array){
        for(int i = 0;i < array.length;i++){
            System.out.print(array[i]+"\t");
        }
    }
    // 查找数组指定的元素
    public int getIndex(int[] array,int dest){
        int head = 0;
        int end = array.length - 1; // 初始的末索引
        boolean isFlag = false;
        int middle = 0;
        sortArray(array);
        while(head <= end){
            middle = (head + end) / 2;
            if(dest == array[middle]){
                isFlag = true;
                break;
            }else if(dest > array[middle]){
                head = middle + 1;
            }else{
                end = middle - 1;
            }
        }
        if(isFlag){
            return middle;
        }else{
            return -1;
        }
    }
}
ArrayUtils.java

②在ArrayUtilsTest.java 文件中测试封装好的方法

public class ArrayUtilsTest {
    public static void main(String[] args){
        ArrayUtils array = new ArrayUtils();
        int[] arr = new int[]{1,5,7,9,845,21,30,12,222,56,-30};
        // 获取数组最大值
        System.out.println(array.getMax(arr));

        // 获取数组最小值
        System.out.println(array.getMin(arr));

        // 数组反转
        array.reverseArray(arr);
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();

        // 数组复制
        int[] arr2 = new int[]{1,2,3};
        int[] newArray = array.copyArray(arr2);
        for(int i = 0;i < newArray.length;i++){
            System.out.print(newArray[i]+"\t");
        }
        System.out.println();

        // 查找元素
        int i = array.getIndex(arr2,4);
        System.out.println(i); // -1 表示没有找到此元素

        // 数组排序
        int[] array3 = new int[]{1,5,8,77,98,33,0,2};
        ArrayUtils a = new ArrayUtils();
        System.out.print("排序前：");
        a.print(array3);
        System.out.println();

        System.out.print("排序后：");
        a.sortArray(array3);
        a.print(array3);
    }
}
ArrayUtilsTest.java

 总结

到此这篇关于Java面向对象类和对象的文章就介绍到这了,更多相关Java面向对象类和对象内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Java面向对象类和对象实例详解

本文链接: https://lsjlt.com/news/142292.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Java面向对象类和对象实例详解
    目录1 - Java面向对象学习的三条主线2 - 面向过程与面向对象3 - 面向对象的三大特征4 - 面向对象分析方法分析问题的思路和步骤5 - 面向对象的思想概述6 - 类和对象的...
    99+
    2024-04-02
  • Java语言面向对象编程思想之类与对象实例详解
    在初学者学Java的时候，面向对象很难让人搞懂，那么今天小编就来为大家把这个思想来为大家用极为简单的方法理解吧。首先我们来简单的阐述面向对象的思想。面向对象：官方的语言很抽象，我们把官方的解释和定义抛开。想想，自己有什么，对！！我们自己有手...
    99+
    2023-05-31
    java 面向对象 之类
  • Python面向对象之类和对象
    目录类定义类定义类和属性类中方法对象方法（普通方法）类方法静态方法魔术方法对象创建对象对象属性总结 类 定义类 所有类名首字母要求大写，多个单词时遵循驼峰命名法 所...
    99+
    2024-04-02
  • python 面向对象、类、对象
    class 类 object 对象 object-oriented programming 面向对象，简称OOP attribute 属性 method 方法 inheritance 继承 python中通过类和对象来实现 ...
    99+
    2023-01-31
    面向对象 对象 python
  • Java面向对象之内部类详解
    目录前言内部类概述内部类的分类成员内部类局部内部类前言 在 Java 中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。本篇博客将总结内部类的使用。 内部类概述...
    99+
    2024-04-02
  • 详解Java的面向对象和面向过程
    目录一. 面向对象1. 概念2. 特点二. 面向过程1. 概念2. 特点3. 面向对象与面向过程的对比三. 结语一. 面向对象 既然我们要学习面向对象，那首先得对其基本概念、特性、对...
    99+
    2023-05-20
    Java面向对象 Java面向过程
  • Python面向对象中类和对象的示例分析
    这篇文章主要介绍了Python面向对象中类和对象的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。什么是面向对象编程？我们是不是听过面向过程，拿来放在一起对比就比较好理...
    99+
    2023-06-22
  • Python面向对象之入门类和对象
    目录什么是面向对象编程？定义类，从具体代码来感受吧！多个类和对象的观察补充一下类的属性（数据部分）总结什么是面向对象编程？ 我们是不是听过面向过程，拿来放在一起对比就比较好理解了。 ...
    99+
    2024-04-02
  • Java 面向对象 之 抽象类 abstract
    转载于 ： http://www.verejava.com/id=16992804621647 public class TestAbstract {public static&n...
    99+
    2023-06-02
  • 【Java】类和对象详解
    文章目录 一、面向对象1.1 什么是面向对象1.2 面向对象与面向过程 二、类的定义和实例化2.1 类的定义2.2 类的创建2.3 类的实例化2.4 类和对象的联系 三、认识 this...
    99+
    2023-10-18
    java 开发语言
  • Java面向对象基础详解
    目录一、前言什么是对象？什么是类？类和对象的关系？类的定义 ？怎么创建对象？格式：创建对象的作用？Phone类下： PhoneDemo下：二、封装封装的好处？Student...
    99+
    2024-04-02
  • Java面向对象和类的定义
    本篇内容介绍了“Java面向对象和类的定义”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！一、面向对象面向对象是在程序中使用对象来映射现实中的...
    99+
    2023-06-15
  • java中的面向对象实例讲解
    这篇文章主要介绍“java中的面向对象实例讲解”，在日常操作中，相信很多人在java中的面向对象实例讲解问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”java中的面向对象实例讲解”的疑惑有所帮助！接下来，请跟...
    99+
    2023-06-20
  • Java 面向对象通过new揭开对象实例化
    目录概念了解第一种情况第二种情况更正说明： 我之前的的标题有点文不对题，我这篇博客的内容明明说的是：java中对象创建的过程，对内存之种底层的东西，我其实提的不太多。 所以我原来的标...
    99+
    2024-04-02
  • 带有类和对象的面向对象的 PHP
    在本文中，我们将探索使用 PHP 类进行面向对象编程的基础知识。 我们将从类和对象的介绍开始，我们将在本文的后半部分讨论一些高级概念，如继承和多态性。 什么是面向对象编程 (OOP)？ 面...
    99+
    2024-02-27
  • python对象及面向对象技术详解
    本文实例讲述了python对象及面向对象技术。分享给大家供大家参考，具体如下： 1 先看一个例子. 本章将讲解这个例子程序: 文件: fileinfo.py： """Framework for gett...
    99+
    2022-06-04
    面向对象 详解 对象
  • Java面向对象:抽象类的学习
    本文介绍了抽象类的基本语法概念,什么是抽象类. Java中抽象类的语法,抽象类的特性 抽象类的作用(抽象类和普通类的区别) 用抽象类实现多态… 抽象类的学习 一.什么是抽象类二.抽象类语...
    99+
    2023-09-11
    java 学习 jvm
  • Java面向对象之内部类案例讲解
    1. 内部类 很多时候我们创建类的对象的时候并不需要使用很多次，每次只使用一次，这个时候我们就可以使用内部类了 1.1 内部类概述 内部类就是在一个类的内部在定义一个类，比...
    99+
    2024-04-02
  • python面向对象，类
    1：类和对象    是面向对象中的俩个重要概念，类是对事物的抽象，比如人类，球类。对象是事物的实例，比如足球，篮球。球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球体出来。2：类的定义    类把需要的变量和函数组合成一起，这种...
    99+
    2023-01-31
    面向对象 python
  • Python面向对象的类和对象怎么使用
    这篇文章主要介绍“Python面向对象的类和对象怎么使用”，在日常操作中，相信很多人在Python面向对象的类和对象怎么使用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Python面向对象的类和对象怎么使用...
    99+
    2023-06-22
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作