java面向对象

最新推荐文章于 2023-12-15 16:49:52 发布

这个名字先用着

最新推荐文章于 2023-12-15 16:49:52 发布

阅读量3.1k

点赞数 2

分类专栏： javase 文章标签： java

本文链接：https://blog.csdn.net/weixin_38568503/article/details/111771060

版权

javase 专栏收录该内容

82 篇文章 11 订阅

订阅专栏

首先我们知道c语言是面向过程的，而java是面向对象的。
1.面向对象：强调的是功能行为，以函数为最小单位，考虑的是一件事情的一步一步的操作过程，考虑怎么做。
比如：把大象装进冰箱；
①：把冰箱门打开
②：把大象塞进去
③：把冰箱门关闭
2.面向过程：强调具备功能的对象。以类/对象为最小单位，考虑谁来做。

面向对象的思想概述：

1.程序员从面向过程的执行者转换成了面向对象的指挥者（不关心具体的步骤，而是找一个已经具备某功能的人，来帮我们做事）。
2.面向对象分析问题的思路和步骤：
（1）根据问题需要，选择问题所针对的现实世界中的实体。
（2）从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
（3）把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
（4）将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

类和对象的定义及关系

类（Class）和对象（Object）是面向对象的核心概念。

类是一组相关属性和行为的集合。可以看成一类事物的模板；是一类对象的描述，是抽象的，概念上的定义。
对象是实际存在的该类事物的每个个体，因而也称为实例（instance）.对象必然具备该类事物的属性和行为。
类与对象的关系：
（1）类是一类事物的描述，是抽象的。
（2）对象是一类事物的实例，是具体的。
（3）类是对象的模板，对象是类的实例。
万事万物皆对象。

在这里插入图片描述

java中的类

1.类的定义：类是一组相关属性和行为的集合==。可以看成一类事物的模板；是一类对象的描述，是抽象的，概念上的定义。

类的成员：
Java类的成员有5类：属性、方法、构造器、代码块、内部类

2.类的定义格式：

public class Student{
	//成员变量
	String name;
	int age;
	//成员方法
	public void show(){
	System.out.println("hello");
	}
}

3.类的组成：

现实世界的生物体，都是由最基本的细胞构成的。同理，java代码世界是由诸多个不同功能的类构成的。
常见类的成员有：
属性：对应类中的成员变量
行为：对应类中的成员方法
Filed=属性=成员变量
Method=(成员)方法=函数
生或中描述事物无非就是描述事物的属性和行为，如人的身高，体重等属性，有说话，打球等行为，这行被java在计算机世界中对应起来成了成员变量和成员方法。

总结：定义类其实就是在定义类中的成员（成员变量和成员方法）

成员变量又分为两类：非静态成员变量（实例变量）和静态成员变量（类变量/静态变量），定义的位置为，在类中，方法外。

由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

实例变量随着对象的产生而产生，随着对象的消亡而消亡。

成员方法：和以前定义方法几乎一样，只不过把static去掉。

4.深入理解类：

4.1.简历的模板就好比类，张三拿到模板后填的是张三自己的信息，李四填李四自己的信息。所以每个人都有一套信息（属性）。
同样的，汽车图纸相当于类，具体的一辆汽车是对象，大楼的图纸相当于类，具体的楼是对象。等等。

4.2.如果创建了一个类的多个对象，则每个对象都能独立的拥有一套类的属性。（非static的）。
意味着，我们修改一个对象的属性a,则不影响另一个对象的属性a的值。

java对象：

1.对象的定义：对象是实际存在的该类事物的每个个体，因而也称为实例（instance），每个对象必然具备该类事物的属性和行为。

2.对象的创建格式：

//类名称  对象名 = new 类名称();
Student stu = new Student();

3.使用，分为两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
（也是就是，想用谁，就用对象名点谁）

代码演示：(使用上一个类的代码Student)

package com.fan.ssm.pojo;

public class StuTest {
    public static void main(String[] args) {
        // 在main方法中创建一个类的实：对象
        Student stu = new Student();
        //对象调用自己的属性
        System.out.println(stu.name);
        //对象调用自己的方法
        stu.show();
    }
}

类和对象的关系：

类是对一类事物的描述,是抽象的。
对象是一类事物的实例，是具体的。
类是对象的模板，对象是类的实例。

对象的内存解析：

在这里插入图片描述

类中属性的使用：

属性（成员变量） vs 局部变量
1.相同点：
1.1定义变量的格式，数据类型变量名 = 变量值
1.2先声明，后使用
1.3变量都有其对应的作用域

2.不同点：
2.1在类中声明的位置不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内部的变量

2.2关于权限修饰符的不同
属性:可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private,public,缺省，protected，–>封装性
目前，大家声明属性时，都使用缺省的就可以了。
局部变量：不可以使用权限修饰符。

2.3默认初始化的情况：(和数组元素的初始化值一样)

属性：类的属性，根据其类型，都有默认初始化值。
整型（byte,short,int ,long）:0
浮点型（float，double）:0.0
字符型（char）:’\u0000’
布尔型（boolean） :false

引用数据类型（类，数组，接口）：null

局部变量：没有默认的初始化值
意味着，我们在调用局部变量之前，一定要显示的赋值。
特别的：形参在调用时，我们通过调用来赋值即可。

2.4在内存中加载的位置：
属性：加载到堆空间中（非static）
局部变量：加载到栈空间。

案例

利用面向对象的的编程方法，设计类Circle计算圆的面积。
代码演示：

package com.fan.ssm.pojo;

public class CircleTest {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.r = 2;
        //对应方式一
        double area = circle.findArea();
        System.out.println(area);

        //对应方式二：面积的方法定义成无返回值的方法。

        //错误的调用,
        // 这个面积的结果肯定不正确。系统会用3作为半径，而不是自带的半径2去计算。其实半径作为圆的自带属性去设计更好一点
        double area1 = circle.findArea1(3);
        System.out.println(area1);

    }
}

class Circle {
    //属性
    double r;

    //求圆的面积:正确的做法
    public double findArea(){
        double area = 3.14 * r * r ;
        return area;
    }

    //错误的做法:
    public double findArea1(double r1){
        double area = 3.14 * r1 * r1 ;
        return area;
    }

}

使用对象数组排序：
比如学生数组，按照成绩/年龄排序，我们冒泡排序的时候比较的是成绩，但是交换的是此成绩所对应的学生，否则只交换成绩，那相当于作弊了。人还是原先的位置。
在这里插入图片描述

变量分类的总结：

按照数据类型分：

在这里插入图片描述
按照在类中声明位置分：

理解万事万物皆对象

1.在java语言范畴中，我们都将功能，结构等封装到类中，通过类的实例化，来调用具体的功能结构，比如Scanner,String;文件：File，网络资源URL
2.涉及到java语言与前端html，后端的数据库交互时，前后端的结构在java层面交互时，都体现为类，对象。

堆栈的解释：

注意：引用类型的变量：只可能存储两类值；null或者地址值；

重点理解！重点理解！重点理解！

Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。

基本类型包括：byte,short,int,long,char,float,double,boolean
引用类型包括：类类型，接口类型和数组。

栈是运行时的单位，而堆是存储的单位。

栈解决程序的运行问题，即程序如何执行，或者说如何处理数据；堆解决的是数据存储的问题，即数据怎么放、放在哪儿。

堆中存的是对象。栈中存的是基本数据类型和堆中对象的引用（有些人会说栈中存局部变量，因为栈中存的是运行时的单位，即方法运行时的变量：局部变量）。一个对象的大小是不可估计的，或者说是可
以动态变化的，但是在栈中，一个对象只对应了一个4btye的引用（堆栈分离的好处：））。
为什么不把基本类型放堆中呢？因为其占用的空间一般是1~8个字节——需要空间比较少，而且因为是基本
类型，所以不会出现动态增长的情况——长度固定，因此栈中存储就够了，如果把他存在堆中是没有什么意义
的（还会浪费空间，后面说明）。可以这么说，基本类型和对象的引用都是存放在栈中，而且都是几个字节的
一个数，因此在程序运行时，他们的处理方式是统一的。

对象数组内存解析：

在这里插入图片描述

匿名对象：

1.理解：我们创建的对象，没有显示的赋给一个变量名。即为匿名对象。
2.特征：匿名对象只能调用一次，后面再想用那个对象不能再使用了。
3.使用：当开发中我们就是使用一次的时候，可以创建匿名对象。

对象数组的一个案例：

代码演示：

1.账户类Account:

package com.fan.domain;

public class Account {
    //账户有余额的属性banlance，和存钱取钱的方法，查余额的方法getBanlance
    private double banlance;//余额

    public Account(double init_banlance) {
        this.banlance = init_banlance;
    }

    public Account() {
    }

    public double getBanlance() {
        return banlance;
    }

    public void setBanlance(double banlance) {
        this.banlance = banlance;
    }

    //自定义的方法
    //存钱的方法
    public void deposit(double amt){
        if(amt > 0){
            banlance += amt;//将存的钱放到账户余额中
            System.out.println("成功存入"+amt+"元");
            double banlance = getBanlance();//查余额
            System.out.println("当前余额："+ banlance);
        }else{
            System.out.println("请存入正确的数值");
        }
    }

    //取钱方法
    public void withdraw(double amt){
        if(amt > banlance){//要取的大于余额
            System.out.println("余额不足");
            return;//提前结束方法。
        }
        banlance -= amt;//将取的钱amt从当前账户减去

        System.out.println(" 取钱成功，取出"+amt+",当前余额" +getBanlance());
    }

    @Override
    public String toString() {
        return "Account{" +
                "banlance=" + banlance +
                '}';
    }
}

2.客户类Customer

package com.fan.domain;

public class Customer {
    //客户有名字firstName+lastName，和自己的账户account
    private String firstName;
    private String lastName;
    private Account account;//客户有账户信息

    public Customer() {
    }

    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", account=" + account +
                '}';
    }
}

3.银行类Bank

package com.fan.domain;

import java.util.Arrays;

public class Bank {
    //银行有多个客户，这里使用客户数组customers；还有客户额数量numberOfCustomer
    private Customer[] customers = new Customer[100];//银行开辟可以存100个客户的容量
    private int numberOfCustomer;//实际客户数量，默认初始化为0

    public Bank() {
    }

    //增加客户的方法，String f,String l为firstName+lastName名字的简写
    public Customer addCustom(String f,String l){//此处也可以设置成void返回值
        //1.创建一个有名字的客户
        Customer customer = new Customer(f, l);
        //2.将客户添加到银行的客户数组中
        customers[numberOfCustomer] = customer;
        numberOfCustomer++;//客户数量加一
        return customer;//返回创建的客户去使用
    }

    //获取客户数量的方法
    public int getNumberOfCustomer(){
        return numberOfCustomer;
    }

    //获取指定索引的客户
    public Customer getCustomer(int index){
        if(index >= numberOfCustomer){//当大于客户实际容量是，返回null
            return null;
        }else{
            return customers[index];
        }
    }

    @Override
    public String toString() {
        return "Bank{" +
                "customers=" + Arrays.toString(customers) +
                ", numberOfCustomer=" + numberOfCustomer +
                '}';
    }
}

4.测试类BankTest

package com.fan.domain;

public class BankTest {
    public static void main(String[] args) {
        Bank bank = new Bank();
        Customer customer1 = bank.addCustom("张三", "三");

        //还可以这样写,bank.getCustomer(0):查找第客户数组的第一个元素
        //bank.getCustomer(0).setAccount(new Account(0));

        customer1.setAccount(new Account(10000));//给添加的客户去设置账户和余额
        Customer customer = bank.getCustomer(0);
        System.out.println(customer);

        //存取操作
        customer1.getAccount().deposit(10000);//存了一万

        //取钱
        customer1.getAccount().withdraw(5000);//取了5000
        System.out.println(customer1.getAccount().getBanlance());

        System.out.println("=============================");
        Customer customer2 = bank.addCustom("张三2", "三2");
        System.out.println("银行客户数："+bank.getNumberOfCustomer());
    }
}

这个名字先用着

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
8
评论
java面向对象

首先我们知道c语言是面向过程的，而java是面向对象的。1.面向对象：强调的是功能行为，以函数为最小单位，考虑的是一件事情的一步一步的操作过程，考虑怎么做。比如：把大象装进冰箱；①：把冰箱门打开②：把大象塞进去③：把冰箱门关闭2.面向过程：强调具备功能的对象。以类/对象为最小单位，考虑谁来做。面向对象的思想概述：1.程序员从面向过程的执行者转换成了面向对象的指挥着。2.面向对象分析问题的思路和步骤：（1）根据问题需要，选择问题所针对的现实世界中的实体。（2）从实体中寻找解决问题相关的属
复制链接

扫一扫