Java关于面向对象

最新推荐文章于 2024-05-05 13:57:09 发布

兔子疼

最新推荐文章于 2024-05-05 13:57:09 发布

阅读量127

点赞数 1

文章标签： java 面向对象编程

本文链接：https://blog.csdn.net/weixin_45899964/article/details/118911900

版权

什么是面向对象

要理解面向对象思想，我们先要知道什么是对象？
“万物皆为对象！！！”《Java编程思想》中提到“万物皆为对象”的概念。它将对象视为一种奇特的变量，它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物，例如人、车、小鸟等，将其表示为程序中的对象。每个对象都具有各自的状态特征（也可以称为属性）及行为特征（方法），java就是通过对象之间行为的交互来解决问题的。
面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决问题中的行为。
类是面向对象中的一个很重要的概念，因为类是很多个具有相同属性和行为特征的对象所抽象出来的，对象是类的一个实例。
Java的核心思想就是面向对象编程（Object-Oriented Prodramming）
面向对象的本质就是：以类的方式组织代码，以对象的组织（封装）数据
从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板
类具有三个特性：封装、继承和多态。
抽象

面向过程&面向对象

面向过程思想

步骤清晰简单，第一步做什么，第二步做什么…

面向过程适合处理一些简单的问题
面向对象思想

物以类聚，分类思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了宏观的把握，从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，仍然需要面向过程思路去处理。

回顾方法及加深

方法的定义

修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2,…){
执行语句
………
return 返回值;
}

break和return的区别：break可以跳出switch语句，结束循环结束整个循环

package Rabbit02.oop.demo01;
//Demo01就是一个类
public class Demo01 {
    //main方法
    public static void main(String[] args) {

    }

    /*
    修饰符 返回值类型  方法名（...）{
          //方法体
          return 返回值；
    }
     */
    // return结束方法，返回一个结果
    public String sayHello(){
        return "hello,world";
    }
    public void print(){
        return ;
    }
    public void  hello(){ //如果返回一个void(空的)只需要return一下就好了
        return;
    }
    public int max(int a,int b){
        return a>b ? a : b; //三元运算符！！
    }
}

方法名：注意规范就OK 驼峰原则见名知意
参数列表：（参数类型，参数名)…一个方法有多个参数
异常抛出：？？？后面会说

    //数组下标越界也是异常：Array index out of bounds
    public void  readFile(String file) throws IOException{  //抛出异常先认识一下

    }

方法的调用：递归
静态方法：简单理解为加了static的方法，调用方法——（类名.方法名；）就可以实现调用

ackage Rabbit02.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        Student.say();
    }

}

package Rabbit02.oop.demo01;

  //学生类
public class Student {

      静态方法
      public static void say(){
          System.out.println("学生说话了");
      }
}

学生说话了

Process finished with exit code 0

非静态方法：实例化这个类 new了一个对象，----（对象类型对象名 = 对象值；）例：Student student = new Student(); 用对象时（对象的名字.方法名；）例：student.say();

package Rabbit02.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        //实例化这个类
        //对象类型 对象名 = 对象值
        Student student = new Student();

        student.say();
    }

}

package Rabbit02.oop.demo01;

  //学生类
public class Student {

      //非静态方法
      public  void say(){
          System.out.println("学生说话了");
      }
}

学生说话了

Process finished with exit code 0

最后，如果有两个静态的方法，它们可以互相调用；而静态方法调用不了非静态方法，因为静态方法是和类一起加载的。

public class Demo02 {
    public static void main(String[] args) {
        //实例化这个类
        //对象类型 对象名 = 对象值
        Student student = new Student();

        student.say();
    }

    // 和类一起加载的
    public static void a(){
        // b();
    }

    //类实例化之后才存在
    public void b(){

    }

}

形参和实参：方法内的参数是形参，实际调用方法所添加进去的数值是实参

ublic class Demo03 {

    public static void main(String[] args) {
        //实际参数和形式参数的类型要保持对应！
        int add = Demo03.add(1,2);
        System.out.println(add);
    }


    public static int add(int a,int b){
        return a+b;
    }

}

值传递和引用传递

值传递：值传递传递的是真实内容的一个副本，对副本的操作不影响原内容，也就是形参怎么变化，不会影响实参对应的内容。

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a); //输出了1


        Demo04.change(a);
        System.out.println(a); //输出了1
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }

}

引用传递：可以理解为值传递–>修改的是拿到的副本,原值并没有发生变化，引用传递–> 指针修改,因为引用指向原对象在在内存中的区域,所有可以修改原对象的值

//引用传递：传递一个对象，本质还是值传递

//不会是因为不理解对象，内存这些概念
public class Demo05 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();

        System.out.println(perosn.name); //输出结果为 null

        Demo05.change(perosn);

        System.out.println(perosn.name); //输出为兔子
    }

    public static void change(Perosn perosn){
        //perosn是一个对象：指向的---->Perosn perosn = new Perosn();这是一个具体的人，可以改变属性！
        perosn.name = "兔子";
    }

}


//定义了一个Perosn类，有一个属性：name
class Perosn{
    String name; //String类型默认值为 null
}

this关键字：之后再说，this是指当前的对象谁调它它就是谁，等学到继承和多态时会了解。

类与对象的关系

类是一种抽象的数据类型它是对某一类事物整体描述定义但是并不能代表某一个具体的事物
◆动物、植物、手机、电脑.
◆ Person类、Pet类、Car类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
◆张三就是人的一个具体实例张三家里的旺财就是狗的一个具体实例。
◆能够体现出特点展现出功能的是具体的实例而不是一个抽象的概念。我们可以将这些思想转换为代码实现!

图片理解：

创建与初始化对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

必须和类的名字相同
必须没有返回类型，也不能写void

构造器必须掌握！

package Rabbit02.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！
        Student xiaoming = new Student();
        Student xh = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xh.name = "小红";
        xh.age = 3;

        System.out.println(xh.name);
        System.out.println(xh.age);
    }
}

package Rabbit02.oop.demo02;

//学生类
public class Student {

    //属性：字段
    String name; //默认值是null
    int age; //默认值是0


    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }

}

//学程序好？对世界进行更好的建模！---宅？
//更应该出去交朋友，音乐，旅游，阅读，

输出：

小明
3
小红
3

Process finished with exit code 0

构造器详解

在Java中,通过提供构造器，类的设计者可确保每个对象都会得到初始化。创建对象时,如果其类具有构造器，Java就会在用户有能力操作对象之前自动调用相应的构造器,从而保证了初始化的进行。
关于构造器的名称

有两个问题:第一，所取的任何名字都有可能与类的某个成员名称相冲突；第二，调用构造器时编译器的责任,所以必须让编译器知道应该调用哪个方法。C++语言中采用的解决方案看起来最简单且符合逻辑，所以在Java中也采用了这种方案:即构造器采用与类相同的名称。由于这点，"每个方法首字母小写"的编码风格并不适用与构造器。
构造器也叫构造方法(constructor)，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。Java 通过new 关键字来调用构造器，从而返回该类的实例，是一种特殊的方法。
不接受任何参数的构造器叫做默认构造器，Java文档中通常使用的术语为无参构造器。
格式：

【访问权限修饰符】类名（形参列表）{

//方法体

}
构造器要点：1. 和类名相同；2. 没有返回值
作用：1. new 本质在调用构造器；2. 初始化对象的值
注意点：定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

package Rabbit02.oop.demo02;

//java---> class
public class Person {

    //一个类即使什么都不写，它也会存在一个方法
    //显示定义构造器

    String name;
    int age;
    //实例化初始值
    //1. 使用new关键字，必须要有构造器，本质是在调用构造器
    //2. 一般用来初始化值
    public Person(){
        this.name = "兔子";
        this.age=123;
        System.out.println("name："+name+"   "+"age："+age);
    }

    //有参构造:一旦定义了有参构造，无参构造必须显式定义
    public Person(String name) {
        this.name = name;
    }
    //Alt+Insert一键生成有参无参

}
/*
    public static void main(String[] args) {

        //new 实例化的一个对象
        Person person = new Person();
        person.age=555;
        System.out.println(person.age);
//        System.out.println(person.name); //输出兔子
//        System.out.println(person.age);

    }
    构造器：
      1. 和类名相同
      2. 没有返回值
    作用：
      1. new 本质在调用构造器
      2. 初始化对象的值
    注意点：
      定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
    this. =

 */

package Rabbit02.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {

        //new 实例化的一个对象
        Person person = new Person();
        person.age=555;
        System.out.println(person.age);
//        System.out.println(person.name); //输出兔子
//        System.out.println(person.age);

    }
}

构造器方法的重载：构造方法也是方法，只不过有特殊的作用而已。与普通方法一样，构造方法也可以重载。如果构造方法中的形参名和属性(成员变量)相同时，需要使用this关键字区分属性与形参。

兔子疼

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java关于面向对象

什么是面向对象要理解面向对象思想，我们先要知道什么是对象？“万物皆为对象！！！”Java编程思想》中提到“万物皆为对象”的概念。它将对象视为一种奇特的变量，它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物，例如人、车、小鸟等，将其表示为程序中的对象。每个对象都具有各自的状态特征（也可以称为属性）及行为特征（方法），java就是通过对象之间行为的交互来解决问题的。面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决问题中的行
复制链接

扫一扫