day9-面向对象

最新推荐文章于 2024-07-24 17:27:32 发布

iCake丶

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量91

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Sakurs/article/details/120773585

版权

1.*面向对象和面向过程的区别：

面向过程：主要关注点是实现的具体过程，因果关系【集成显卡的开发思路】

*优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。

*缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑。面向过程的方式导致软件元素之间”耦合度“非常高，只要一环出现问题，整个系统都将受到影响。最终导致软件的”扩展能力“差，没有独立体的概念，所以无法达到组件的复用。

面向对象：主要关注点是对象【独立体】能完成哪些功能【独立显卡的开发思路】

*优点：耦合度低，扩展能力强。更容易解决现实世界当中更复杂的业务逻辑。组件的复用性强。

*缺点：前期投入成本过高，需要独立提的抽取，大量的系统分析和设计。

c语言是纯面向过程的，c++半面向对象，java是纯面向对象的语言。

2.面向对象的三大特征：

封装、继承、多态

3.采用面向对象的方式开发软件，生命周期当中：

【整个生命周期中贯穿使用oo面向对象方式】

**采用面向对象分析OOA、**采用面向对象设计OOD、**采用面向对象编程OOP

4.类和对象的概念：

类：

类在现实世界当中是不存在的，是一个模板，是一个概念，是人类思考抽象的结果。

类代表了一类事物。

在现实世界当中，对象A与对象B之间具有的共同特征，进行抽象总结出的一个模板，这个模板就叫类。

类{

属性；描述对象状态信息
方法；描述对象动作信息

}

对象

对象是实际存在的个体，现实世界当中实际存在的。

类------》对象的过程：实例化 /instance

对象-----》类的过程：抽象

5.类的编写：

语法结构：

【修饰符列表】class 类名{

}

**重点：属性通常是采用一个变量的形式来完成定义的。在类体当中，方法体之外的变量被称为”成员变量“，”成员变量“没有赋值，系统赋默认值，一切向 0 看齐

java语言中包括了两种数据类型：

基本数据类型和引用数据类型

java语言当中所有的引用数据类型都是.class

6.对象的创建和使用：

通过一个类可以实例化N个对象

实例化对象的语法：new 类名（）；/ 类名对象名 = new 类名（）

（对象名是一个变量名，是一个局部变量，在栈内存中存储）

new是java语言当中的一个运算符

new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间。

方法区内存：在类加载的时候，里边储存源代码片段。
栈内存：类中方法的调用会出现压栈的动作进入栈内存。
堆内存：新的对象的创建会占用堆内存的空间，储存在堆内存里。

对象和引用的区别：new运算符在堆内存之中开辟的内存空间称为对象。引用只是一个变量，只不过变量中保存了应一个java对象的内存地址。

在java中，开发者不能直接操作堆内存，因为java中没有像c语言一样指针的概念，只能通过“引用”去访问堆内存当中的对象内部的实例变量。
访问实例变量的语法格式：
读取数据：引用.变量名
修改数据：引用.变量名 = 值

注意：实例变量不能直接采用“类名”的方式访问，因为实例变量是对象级别的变量，变量储存在java对象的内部，必须先有对象，通过对象才能访问实例变量，不能直接通过“类名”。

关联对象列表：A（源代码）

public class ooTest1 {
    public static void main(String[] args) {
        // 实例化对象
        husband husband1 = new husband();
        husband1.name = "husband1";
        //实例化对象
        wife wife1 = new wife();
        wife1.name = "wife1";
        //关联链表
        husband1.wife1= wife1;
        wife1.husband1 = husband1;

        System.out.println(husband1.wife1.name);

    }
}

//两个类的主要声明；
public class wife {
    String name;

    husband husband1;
}


public class husband {
    String name;

    wife wife1;


}

关联对象B源代码：（两个类的关联关系，将两个类之间的实例化对象相关联）

public class ooTest1 {
    public static void main(String[] args) {
        computer computer1 = new computer();
        computer1.BARND = "惠普";
        computer1.COLOR = "远峰蓝";
        computer1.XINGHAO = "2080Ti";

        student student1 = new student();
        student1.NAME = "张欣哲";
        student1.NUM = 2018030308;

        //列表链接
        student1.computer =computer1;
        computer1.user = student1;

        System.out.println(student1.computer.BARND);
        System.out.println(computer1.user.NAME);
    }
}

//两个类的定义：
public class computer {
    String BARND;
    String XINGHAO;
    String COLOR;

    student user;
}


public class student {
    int NUM ;
    String NAME;

    computer computer;
}

java中实例化对象之后的内存调用机制图解

垃圾回收机制（空指针异常）

public class ooTest1 {
    public static void main(String[] args) {
        Customer c = new Customer();
        c.id = 25;
        System.out.println(c.id);

        // 以下程序编译可以通过，符合语法
        // 运行出现空指针异常
        // 空引用访问“实例”相关的数据
        c = null;
        System.out.println(c.id);
    }
}

封装性：

一个类的属性在外部的对象中可以随意访问，这样的一个程序是不安全的。

封装的好处：

1.封装之后，对于事物来说，就看不到事物复杂的一面，只能看到简单的一面。复杂性的封装对外仅仅提供简单的操作入口。

2.封装之后才会形成真正的“对象”，真正的“独立体”。

3.封装就意味着程序可以重复使用，并且这个事物应该适应性比较强，在任何场合都可以使用。

4.封装之后，对于事物本身，提高了安全性。

封装的步骤：

1.所有的属性私有化，属性前添加private关键字。

2.对外提供简单的操作入口，之后想要访问age属性，必须通过这些简单的入口访问。一般对属性的操作是读取属性get，和修改属性set，所以提供这两个公开的方法。

3.set方法的命名规范：

public static void set + 属性名首字母大写（形式参数a）{

属性值 = a
}

4.get方法的命名规范：

public static void get + 属性名首字母大写（）{

return 属性名
}

注意：setter 和 getter 方法没有static方法，

有static关键字的方法如何调用呢？类名.方法名（实参）

没有static关键字的方法如何调用呢？引用.方法名（实参）

// 封装的调用
public class ooTest1 {
    public static void main(String[] args) {

        partUser userTest = new partUser();
        userTest.setAge(200);
        int result = userTest.getAge();
        System.out.println(result);
    }
}


// 封装好的源类代码
public class partUser {
    private int age;

    public void setAge(int a) {
        if (a < 0 & a > 100) {
            System.out.println("您输入的年龄不合法");
        } else {
            age = a;
        }
    }
    public int getAge(){
        return age;
    }
}

封装性的构造方法：【alt+insert】

1.java类中的构造方法：

1.构造方法又被称为构造函数/构造器/Constructor

2.构造方法语法结构：

【修饰符列表】构造方法名（形式参数列表）{
构造方法体；
}

3.对比普通方法的语法结构：

【修饰符列表】返回值类型方法名（形式参数列表）{
方法体；
}

4.对于构造方法来说：“返回值类型”不需要指定，并且也不能写void，只要写上void，变成普通方法了。

5.对于构造方法来说，构造方法的方法名必须和类名保持一致。

6.构造方法的作用：通过构造方法的调用，可以创建对象。

7.构造方法怎么调用：方法修饰符中由static的时候：类名.方法名（实参列表），没有static的时候：引用.方法名（实参列表）

new 构造方法名（实参列表）

8.构造方法调用执行以后的返回值：构造方法返回的就是他本身，有返回值，返回自身。

9.当一个类中没有定义任何构造方法的话，系统默认给该类提供一个无参数的构造方法，这个构造方法被称为缺省构造器。

10.当一个类显示的将构造方法定义出来了，那么系统不会在默认为这个类提供缺省构造器了。建议开发者中手动定义无参数构造方法。

11.构造方法重载机制

2.构造方法的作用：

1.创建对象

2.创建对象的同时，初始化实例变量的内存空间。【给实例变量赋值】

成员变量之实例变量，属于对象级别的变量，必须先有对象才有能实例变量。实例变量没有手动赋值的时候，系统默认赋值。类加载的时候只加载了代码片段，还没来得及创建对象，所以此时实例变量没有初始化，实际上实例变量的内存空间是在构造方法执行过程中完成开辟、初始化的。系统在默认赋值的时候，也是在系统构造方法的过程中完成的。

源代码：

public class construct {
    public static void main(String[] args) {
        Account account1 = new Account();

    }
}


// 源类
public class Account {

    private String name; // 实例变量//对象变量

    private int id ;
    
    //无参数的构造器
    public Account(){
        // 初始化实例变量的内存空间
        // id = 0
        // String = null
    }
    //有参数的构造器
    public Account(String a, int b){
        name = a;
        id  =b;
    }
    
    public void setId(int a){
        id = a ;
    }
    public int getID(){
        return id;
    }

    public void setName(String a){
        name = a;
    }
    public String getName(){
        return name;
    }
}

对象和引用的概念：

对象：目前在使用new运算符在堆内存中开辟的内存空间称为对象。

引用：是一个变量，不一定是局部变量，还可能是成员变量。引用保存了内存地址，指向了堆内存当中的对象，所有访问实例相关的数据，都需要通过引用的方式访问，只有通过引用才能找到对象。只有一个空的引用，访问对象的实例相关的数据会出现空指针异常。

参数的传递：

方法在调用的时候，涉及到参数传递的同时，参数是如何传递的？

方法调用的时候，参数在传递过程中，传递的实际是变量中的值，只不过有时候是“值”，有时候是实例对象的内存地址。

源代码：

public class construct {
    public static void main(String[] args) {
        Account account1 = new Account();
        int i  = 1;
        add(i);
        System.out.println(i);
    }

    public static void add( int a){
        a++;
        System.out.println(a);
    }
}

【区别】在类中实例化对象的参数值在运行方法之后：

源代码：

public class partCanshu {
    public static void main(String[] args) {
        //实例化对象
        User userTest = new User(20);
        User userTest2 = new User(30);

        //对象1参数
        add(userTest);
        System.out.println("main方法中的age"+ userTest.age);

        //对象2参数
        add(userTest2);
    }
    public static void add(User u){
        u.age ++;
        System.out.println("add方法中的age"+ u.age);
    }
}

class User{
    //实例变量
    int age;
    //构造方法
    public User(int i){
        age = i;
    }
}

详解图：

this关键字：

关于java语言当中的this关键字，翻译为“这个”

this为一个引用，是一个变量，其中保存了内存地址指向了自身，this储存在jvm的堆内存之中

创建无数多个对象的时候，有无数个this，每一个this都指向自身。

重点：没有static关键字的方法是实例方法，没有static关键字的变量是实例变量，是对象级别的

public class Customer {
    String name ;


    public Customer(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

this的作用：JVM工作图，所以一般this. 在实例变量中可以省略。

public class Customer {
    String name ;


    public Customer(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void shopping(){
        //System.out.println(name + "is going to shopping");
        System.out.println(this.name + "is going to shopping");
    }
}

this出现在实例方法当中，指向当前正在执行这个动作的对象

当带有static的方法，执行过程中没有对象的参与，因为带有static关键字的方法是通过类名的方式来访问的，或者说这个上下文没有当前对象，自然也不存在“this”——————》this不能存在有static的方法当中。

源代码（如何在静态方法当中访问实例对象的属性）（但是无法访问当前对象的name）

import java.util.concurrent.Callable;

public class Customer {
    String name = "sles";


    public Customer(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public static void dosme(){
        System.out.println();
    }

    //在静态方法当中访问实例变量的方法就是在静态方法中创建一个实例对象，然后访问它的属性。
    public static void doother(){
        Customer c1 = new Customer();
        System.out.println(c1.name);

        }
    }
    public void shopping(){
        System.out.println(name + "is going to shopping");
    }
}

-----------------------------------------------------------》大纲结构与图引用b站动力节点java零基础教程视频

iCake丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day9-面向对象

*面向对象和面向过程的区别：面向过程：主要关注点是实现的具体过程，因果关系【集成显卡的开发思路】 *优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。 *缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑。面向过程的方式导致软件元素之间”耦合度“非常高，只要一环出现问题，整个系统都将受到影响。最终导致软件的”扩展能力“差，没有独立体的概念，所以无法达到组件的复用。面向对象：主要...
复制链接

扫一扫