Java基础 面向对象-面向过程-类和对象的概念

鳄鱼君

发表文章数:642

Vieu四代商业主题

高扩展、安全、稳定、响应式布局多功能模板。

¥69 现在购买
首页 » Java » Java基础 面向对象-面向过程-类和对象的概念

面向过程:主要关注点是,实现的具体过程,因果关系

  1. –优点:对于业务逻辑比较简单的程序,可以达到快速开发,前期投入成本较低
  2. –缺点:采用面向过程的方式开发很难解决非常复杂的业务逻辑,面向过程导致软件元素之间的“耦合度”非常高,只要其中一个环节出问题,整个系统都会受到影响。导致最终软件的扩展力差,由于没有独立体的概念,所以无法达到组件复用。

面向对象:主要关注点是,对象【独立体】能完成哪些功能

  1. –优点:耦合度低,扩展力强,更容易解决现实世界当中更复杂的业务逻辑,组件复用性强
  2. –缺点:前期投入成本较高,需要进行独立体的抽取,大量的系统分析与设计

面向对象的三大特征:封装、继承、多态,所有面向对象的编程语言都有着三大特征!
采用面向对象的方法开发一个软件,整个生命周期中贯穿使用OO面向对象方式:

  1. 面向对象的分析:OOA
  2. 面向对象的设计:OOD
  3. 面向对象的编程:OOP

类和对象的概念

什么是类?

  1. 类在现实世界是不存在的,是一个模板,是人类大脑思考抽象的结果
  2. 类代表了一类事物
  3. 在现实世界当中,对象A与对象B之间具有共同特征,进行抽象总结出一个模板,这个模板被称为类

什么是对象?

  1. 对象是实际存在的个体,现实世界当中实际存在
  2. 描述一下软件开发的过程:
  3. 1.程序员先观察现实世界,从现实世界当中寻找对象
    2.寻找了N多个对象之后,发现所有的对象都有共同特征
    3.程序员在大脑中形成了一个模板【类】
    4.Java程序员可以通过java代码来表述一个类
    5.Java程序中有了类的i当以
    6.然后通过类就可以创建对象
    7.有了对象之后,可以让对象直接写作起来形成一个系统

类–【实例化】–对象,对象又被称为实例/instance,对象–【抽象】–类

类描述的是对象的共同特征,例如身高,体重等,这个身高特征在访问的时候,必须先创建对象,通过对象去访问这个特征。比方说人,可以想象为一个类,人具有名字、身高、性别、年龄,这些属于状态信息,叫做类的属性;人可以吃、跳、学习、睡觉,这些属于动作信息,叫做类的方法

类的定义

语法结构:

[修饰符列表] class 类名{
}

假设一个学生可以当作一类人来处理,学生类用来描述所有学生对象的共同特征,学生对象的状态信息:名字、性别、年龄,这些叫做属性,通常是采用变量的形式来完成定义的;

//定义一个类,类名Student
//Student是一个类,代表了所有的学生对象,是一个学生模板

public class Student
{
    //属性,描述的是对象的状态信息
    //在类体中,方法体之外定义的变量称为“成员变量”
    //成员变量没有赋值,系统默认赋值
    String name; //名字
    boolean sex;
    int age;

    //方法,描述的是对象的动作信息

}

学生对象的动作信息:吃饭、睡觉、学习,这些叫做方法

//定义一个类,类名Student
//Student是一个类,代表了所有的学生对象,是一个学生模板

public class Student
{
    //类体 = 属性 + 方法

    //属性,定义在类体中,被称为成员变量
    // 名字不能通过“类”直接访问,成员变量又叫做:实例变量
    //  对象又被称为实例,实例变量又被称为对象变量【对象级别的变量】
    //不创建对象,变量的内存空间是不存在的

    //通过一个类,可以实例化N个对象
    //实例化对象:new 类名();
    String name; //名字
    boolean sex;
    int age;
    

    //方法
}

基本数据类型前面提到过,这里说一下引用数据类型,其实它就是一个类,例如String.class、System.class等,它们属于引用数据类,是Java程序为我们提供,我们可以直接使用。我们编写了一个学生类,呢么编译之后就会生成对应的class字节码文件,呢么Student类就属于引用数据类型,只不过是我们自己定义的!

对象的创建和使用

前面仅仅是定义一个Student学生类,需要实例化才能使用这个类,实例化对象使用new运算符,它的作用是创建对象,在JVM堆内存中开辟新的内存空间

public class OOtest
{
    public static void main(String[] args){

        //student是一个引用数据类型
        //name是一个变量名
        //new Student()是一个学生对象
        student s = new Student();
    }
}

方法区内存:在类加载的时候,class字节码代码片段被加载到该内存空间
栈内存(局部变量):方法代码片段执行的时候,会给该方法分配内存空间,在栈内存中压栈/入栈
堆内存:new的对象在是在堆内存中存储

首先在方法区内存中,装载有OOTest.class、String.class、Student.class(前面编译生成的)字节码文件,。首先程序会执行main方法,这时候就会出现压栈,在栈内存为main方法开辟内存空间。new Student()会创建一个学生对象,此时会在堆内存开辟空间存储这个对象,这个对象中存储有成员变量,这些变量有系统默认值,例如name、sex、age,这些属于实例变量。new完成,会在栈内存中开辟一块内存,存储变量s,s指向Student对象的内存地址,这个s叫做引用。

对象:new运算符在堆内存中开辟的空间称为对象
引用:引用保存了对象的内存地址。是一个变量,只不过,这个变量保存了另一个Java对象的内存地址
Java语言中,程序员只能通过“引用”去访问堆内存当中对象内部的实例变量!访问实例变量的语法格式:

  1. 读取数据:引用.变量名;
  2. 修改数据:引用.变量名 = 值;

我们重新修改一下Student类:

public class Student
{
    String name;
    boolean sex;
    int age;
    char eq;
    long on;
}

然后编写一个OOTest.java程序:

public class OOTest
{
    public static void main(String[] args){
        Student s = new Student();

        String name = s.name;
        boolean sex = s.sex;
        int age = s.age;
        char eq = s.eq;
        long on = s.on;

        System.out.println("姓名" + name); //null
        System.out.println("性别" + sex); //false
        System.out.println("年龄" + age);  //0
        System.out.println("EQ" + eq);  //空值
        System.out.println("未知属性" + on);  //0

        //也可以这样访问实例变量
        System.out.println(s.name);
        System.out.println(s.sex);
        System.out.println(s.age);
        System.out.println(s.eq);
        System.out.println(s.on);
    }
}

现在我想要修改Student对象中的实例变量,就是把内存空间修改:

public class OOTest
{
    public static void main(String[] args){
        Student s = new Student();

        s.name = "鳄鱼君";
        s.sex = true;
        s.age = 18;
        s.eq = '5';
        s.on = 1L;

        System.out.println(s.name);
        System.out.println(s.sex);
        System.out.println(s.age);
        System.out.println(s.eq);
        System.out.println(s.on);

        //编译报错,name实例变量不能直接采用“类名.”的方式访问
        //name是实例变量,对象级别的变量,存储在java对象的内部,必须先有对象,通过对象访问
        //System.out.println(Student.name);

    }
}

再实例化一个新的对象:

public class OOTest
{
    public static void main(String[] args){
        Student stu = new Student();
      
    }
}

此时会在堆内存中开辟一个新的空间存储Student类,new之后,会将Student对象的内存地址赋值给stu,stu就是引用,他保存了Student对象的内存地址。引用s和stu指向不同的堆内存。
练习:
创建一个家庭住址类

public class Address
{
    //城市
    String city;

    //街道
    String street;

    //邮编
    String zipCode;

}

编写一个用户类:

public class User
{
    //用户编号
    int num;

    //用户名
    //String是引用数据类型,代表字符串
    //name属于实例变量,也是引用
    String name;

    //家庭住址
    //Address是我们定义一个类
    //Address类编译会生成class字节码
    //也属于引用数据类型
    //addr属于实例变量,也是引用
    Address addr;
}

编写一个测试类:

public class OOTest
{
    public static void main(String[] args){
        //创建User对象
        User u = new User();

        //输出User对象内部的实例变量
        System.out.println(u.num); //0
        System.out.println(u.name);//null
        System.out.println(u.addr);//null

        //修改User对象内部实例变量的值
        u.num = 110;
        u.name = "鳄鱼君";
        u.addr = new Address();

        //通过u访问实例变量
        System.out.println("鳄鱼君住址:" + u.addr.city);//null
        
        u.addr.city = "郑州";
        System.out.println("鳄鱼君住址:" + u.addr.city);//郑州
    }
}
public class OOTest
{
    public static void main(String[] args){
        //创建User对象
        User u = new User();
        //u.addr = new Address();

        Address a = new Address();
        u.addr = a;
        System.out.println(u.addr.city);//null

        a.city = "郑州";
        System.out.println(u.addr.city);//郑州
    }
}

JVM(Java虚拟机)主要包括三块内存空间,分别是:方法区内存栈内存堆内存
堆内存和方法区内存各有一个,一个线程一个栈内存
方法调用的时候,该方法所需要的内存空间在栈内存中分配,成为压栈,方法执行结束之后,该方法所属的内存空间释放,称为弹栈
栈中主要存储的是方法体中的局部变量
方法的代码段以及整个类的代码片段存储在方法区内存中,在类加载对象的时候,这些代码片段会载入
在程序执行过程中使用new运算符创建java对象,存储在堆内存中,对象内部有实例变量,所以实例变量存储在堆内存中
变量分类:
局部变量【方法体中声明】
成员变量【类体中声明】
–实例变量【前边修饰符没有static】
–静态变量【前边修饰符有static】

静态变量存储在方法区内存中


三块内存中变化频繁的是栈内存,最先有数据的是方法区内存,垃圾回收主要针对堆内存
垃圾回收器【自动回收机制,GC机制】什么时候会考虑将某个java对象的内存回收?
没有更多的引用指向的java对象,这个对象无法被访问,因为访问对象只能通过引用的方式

空指针异常

java.lang.NullPointerException,空引用访问“实例”相关的数据一定会出现空指针异常,程序编译通过,但是运行出现空指针异常:

public class OOTest
{
    public static void main(String[] args){
        //创建User对象
        User u = new User();
        System.out.println(u.addr);

        u = null;
        System.out.println(u.addr);
    }
}

练习:定义一个计算机类,属性:品牌、型号、颜色;定义一个学生类,属性:学号、姓名、笔记本电脑:
计算机类

public class Notebook
{
    //品牌
    String brand;
    //型号
    String model;
    //颜色
    String color;
}

学生类

public class Student
{
    //学号
    int number;
    //姓名
    String name;
    //笔记本电脑
    Notebook note = new Notebook();
}

测试类

/*  每个类中都可以编写主方法,但是一般情况下
    一个系统只有一个入口,所以主方法一般写一个
*/

public class OOTest
{
    public static void main(String[] args){
        //创建一个学生对象
        //stu1局部变量,引用,stu1保存的内存地址指向堆内存的Student对象
        Student stu1 = new Student();

        //属性赋值
        stu1.number = 110;
        stu1.name = "鳄鱼君";
        stu1.note.brand = "Mac";
        stu1.note.color = "pink";
        stu1.note.model = "i3";

        //访问实例变量
        System.out.println("学号:" + stu1.number);
        System.out.println("姓名:" + stu1.name);
        System.out.println("笔记本电脑牌子:" + stu1.note.brand);
        System.out.println("笔记本电脑颜色:" + stu1.note.color);
        System.out.println("笔记本电脑型号:" + stu1.note.model);
    }
}

也可以编写在一个java源文件中:

class Notebook
{
    //品牌
    String brand;
    //型号
    String model;
    //颜色
    String color;
}

class Student
{
    //学号
    int number;
    //姓名
    String name;
    //笔记本电脑
    Notebook note = new Notebook();
}


public class OOTest
{
    public static void main(String[] args){
        //创建一个学生对象
        //stu1局部变量,引用,stu1保存的内存地址指向堆内存的Student对象
        Student stu1 = new Student();

        //属性赋值
        stu1.number = 110;
        stu1.name = "鳄鱼君";
        stu1.note.brand = "Mac";
        stu1.note.color = "pink";
        stu1.note.model = "i3";

        //访问实例变量
        System.out.println("学号:" + stu1.number);
        System.out.println("姓名:" + stu1.name);
        System.out.println("笔记本电脑牌子:" + stu1.note.brand);
        System.out.println("笔记本电脑颜色:" + stu1.note.color);
        System.out.println("笔记本电脑型号:" + stu1.note.model);
    }
}

未经允许不得转载:作者:鳄鱼君, 转载或复制请以 超链接形式 并注明出处 鳄鱼君
原文地址:《Java基础 面向对象-面向过程-类和对象的概念》 发布于2020-08-04

分享到:
赞(0) 赏杯咖啡

评论 抢沙发

1 + 1 =


文章对你有帮助可赏作者一杯咖啡

支付宝扫一扫打赏

微信扫一扫打赏

Vieu4.6主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。
切换注册

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录
切换登录

注册