Javaopp面向对象01

苏十八

已于 2024-02-20 09:19:59 修改

阅读量801

点赞数 20

文章标签： java 开发语言 idea 笔记学习

于 2024-01-24 15:32:19 首次发布

本文链接：https://blog.csdn.net/2303_77543831/article/details/135728945

版权

面向过程和面向对象

面向过程和面向对象都是程序设计的一种风格（思想）

面向过程适合简单问题

面向对象适合复杂问题，先宏观的分类设计，具体某一个步骤落地时，又需要面向过程，他们是相辅相成的

面向过程的程序设计思想：

（procedure -Oriented Programming),简称POP

是以函数（一个一个的功能）为结构进行代码组织；

解决问题时，分析实现所需的步骤，然后一步一步实现即可；

典型的代表语言：c语言。

早期的编程语言设计思想，结构简单。

相对于面向对象语言，扩展能力差、后期维护难度较大。

面向对象的程序设计思想：

（Object Oriented Programming），简称OOP

是以类为单位进行组织的，每种事物都具备自己的属性和行为/功能

先根据客观的事物进行抽象（设计为程序）

然后由抽象创造出具体，最终使用的是具体。

类：一类问题/分类 String，Math，Arrays，Scanner

/*publice class 人类{

定义人有什么属性（变量）

人有什么功能（方法）

}*/

典型的代表语言：c++,c#,java,python......

/*动物类{

动物共有属性和功能（代码复用）

}

猫继承动物{

定义自己特有属性的功能（扩展自己的功能）

}

狗继承动物{

定义自己特有属性的功能

}

猫和狗可在自己的类中再去定义自己特有的功能，例如猫会捉老鼠狗不会*/

是一种设计者思维，适合解决复杂的问题，扩展性更好，维护性更高。

开车的动作简单，面向过程的思想就可以解决

造车就比较复杂了，适合使用面向对象思想，要进行分类

面向过程适合简单问题，后来的程序设计越来越复杂，单纯面向过程就难以胜任程序设计需求

面向对象适合复杂问题，先宏观的分类设计，具体某一个步骤落地时，又需要面向过程，他们是相辅相成的

面向过程关心怎么解决问题，步骤有哪些...

面向对象关心谁来解决问题（类String,Arrays...冰箱类，人类）

类和对象

类（class）和对象（object）是面向对象的核心概念

类

定义：

具有相同特征的事物的抽象描述（定义）

同一类事物的抽象描述（定义）概念，模板

结构：

变量属性名词

package day1.demo1;
public class Car {
    /*
      定义属性  成员变量  直接在类{ }中定义的内容，称为类的成员
    */
    String name;
    String color;
    int price;
    //...... 
}

方法行为动词

package day1.demo1; 
public class Car { 
    /*
      定义方法 成员方法
    */
    public void run(){
        System.out.println("汽车行驶");
    }
    public void stop(){
        System.out.println("汽车停止");
    } 
}

构造方法

块没有名字的一个代码块

内部类在类的内部定义类（嵌套）

成员变量（类的共有属性）

变量按照类型：
基本数据类型
引用数据类型
变量按照位置：
成员变量（在类中定义）
可以使用基本数据类型，也可以使用引用数据类型
java中在使用前都必须初始化
成员变量可以不对其初始化，系统会默认进行初始化（默认值）
成员变量可以在成员方法，构造方法，代码块中使用
局部变量（在方法中定义）
局部变量不会自动初始化
方法的参数也是局部变量

类中的成员变量和成员方法都必须通过创建出来的对象调用

对象

定义:

是以类为模板，在内存中创建出来的具体实例

该类事物具体存在的一个个体，是真实存在，也称为实例

万事万物（大千世界中具体存在的东西），皆为对象。

人类--->一类群体概念张三--->具体的人对象

电脑--->一类电脑概念我的电脑--->可以使用的，具体的，对象

编程是对现实生活事物的体现，根据现实事物进行抽象（定义）。

先设计类（定义某一类事物的功能）
Car car = new Car();
new Car(); new关键字用来创建对象，以Car类为模板,在内存中开辟一块独立的空间，用来存储对象信息
Car()构造方法，每个类中默认都有一个，方法名字与类名相同的
Car(类型)car(变量名) 声明一个Car类型的变量
= 把右边的对象地址赋给左边的变量，用变量在后面的程序中表示内存中的对象

package day1.demo1;

public class TestCar {

    public static void main(String[] args) { 
        Car bmcar = new Car();
        bmcar.name = "宝马";
        bmcar.color = "黑色";
        bmcar.price = 50000;
        bmcar.run();
        bmcar.stop();
        Car bccar = new Car();
        bccar.name = "奔驰";
        bccar.color = "红色";
        bccar.price = 40000;
        bccar.run();
        bccar.stop();

    }
}

类和对象的关系

构造方法

Car():类的构造方法，类没有定义时，会默认又一个无参的构造方法
构造方法的名字与类名相同
定义：构造方法名字与类名相同，且没有返回值，且不需要void修饰
特点：类中没有定义时，会默认有一个无参的构造方法，在无参的构造方法中为成员变量赋初始值
我们还可以定义有参的构造方法，通过有参的构造方法为成员变量进行初始化赋值
一旦类中定义了有参的构造方法，那么默认的无参的构造方法便会失效
如果需要，需要显示的定义无参构造方法
作用：用来对新创建的对象中的成员变量进行初始化

package day1.demo1; 
public class Car { 
    String name;
    String color;
    int price;
    //......

    //隐式赋值
    public Car(){
        System.out.println("无参构造方法");
        //下三行代码不进行初始化也没有问题，这里只做展示
        name=null;
        color=null;
        price=0;
    }

    public Car(String n,String c,int p){
        System.out.println("有三个参数的构造方法");
        name=n;
        color=c;
        price=p;
    }

    public void run(){
        System.out.println(name+"汽车行驶");
    }
    public void stop(){
        System.out.println(name+"汽车停止");
    }
}

package day1.demo1;

public class TestCar {

    public static void main(String[] args) { 
        Car bmcar = new Car();
        System.out.println(bmcar.name);//null
           bmcar.name = "宝马";
           bmcar.color = "黑色";
           bmcar.price = 50000;
           bmcar.run();
           bmcar.stop();

        Car bccar = new Car("奔驰","红色",40000);
        Car dzcar = new Car("大众","白色",50000);

        System.out.println(bccar.name+bccar.color+bccar.price);
        System.out.println(dzcar.name+dzcar.color+dzcar.price); 
    }
}

方法的重载

方法重载:
在一个类中，有多个方法名相同，但参数个数不同的方法，称为方法重载
如何区分名称相同的多个方法:
通过参数的个数，类型，顺序来进行区分
方法重载的意义：做同一件事，但是我们可以传入不同的参数，来进行不同的处理

注意：方法的重载与方法的返回值没有任何关系

package day1.demo2; 
public class Car { 
    String name;
    String color;
    int price;
    //...... 

    //隐式赋值
    public Car(){
        System.out.println("无参构造方法");
        name=null;
        color=null;
        price=0;
    }

    public Car(String n,String c,int p){
        System.out.println("有三个参数的构造方法1");
        name=n;
        color=c;
        price=p;
    }

    public Car(String n,int p,String c){
        System.out.println("有三个参数的构造方法2");
        name=n;
        color=c;
        price=p;
    } 

    public void run(){
        System.out.println(name+60+"速度行驶");
    }
    public void run(int speed){
        System.out.println(name+speed+"速度行驶");
    }
    public void stop(){
        System.out.println(name+"汽车停止");
    }
}

package day1.demo2;

public class TestCar {

    public static void main(String[] args) { 
        Car bmcar = new Car();
        System.out.println(bmcar.name);//null
        bmcar.name = "宝马";
        bmcar.color = "黑色";
        bmcar.price = 50000;
        bmcar.run();
        bmcar.stop();

        Car bccar = new Car("奔驰","红色",40000);
        Car dzcar = new Car("大众","白色",50000);
        Car adcar = new Car("奥迪",50000,"白色");

        System.out.println(bccar.name+bccar.color+bccar.price);
        System.out.println(dzcar.name+dzcar.color+dzcar.price);
}

对象与引用

package day1.demo3;

public class Car {
    String name;
    String color;
    int price;

    public Car(){

    }

    public void showInfo(){
        System.out.println(name+":"+color+":"+price);
    }
}

package day1.demo3;


public class TestCar {
    public static void main(String[] args) {
        Car car1 = new Car();
            car1.name = "宝马";
            car1.color = "白色";
            car1.price = 30000;
            car1.showInfo();

        Car car2 = new Car();
            car2.name = "奔驰";
            car2.color = "白色";
            car2.price = 30000;
            car2.showInfo();
        Car car3 = car2;
            car3.name = "大众";
        System.out.println(car2.name);//大众
        System.out.println(car3.name);//大众
    }
}

值传递

package day1.demo4;

public class Testvalue {
    public static void main(String[] args) {
        int a = 10;
        Testvalue t = new Testvalue();
                  t.test(a);//基本类型在传参时，将值直接赋给对应的形参x
        System.out.println(a);
    }

    public void test(int x){
        x = 20;//形参x发生变化，不会影响 实参a的值
        System.out.println(x);
    }
}

package day1.demo4;

import day1.demo3.Car;

public class TestRef {
    public static void main(String[] args) {
        Car car = new Car();
            car.name = "宝马";
        TestRef testRef = new TestRef();
                testRef.test(car);
        System.out.println(car.name);//奔驰
    }

    public void test(Car car1){
        car1.name = "奔驰";
    }
}