java面向对象

最新推荐文章于 2024-08-26 16:40:46 发布

巅峰V红尘

最新推荐文章于 2024-08-26 16:40:46 发布

阅读量83

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_45068111/article/details/109382658

版权

笔记专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文详细介绍了面向过程和面向对象的设计思想，包括它们各自的特点、适用场景和相互关系。Java类和对象的概念也被深入讲解，涵盖了类的结构、变量、方法、构造器、对象创建和成员访问。此外，还提到了方法重载、对象与引用的区别、静态关键字的作用以及代码块和包的管理。文章最后讨论了访问权限修饰符的使用及其重要性。

摘要由CSDN通过智能技术生成

面向过程和面向对象的设计思想

面向过程（procedure oriented programming）缩写POP

面向过程就是分析得出要进行的每一个步骤一步一步的执行。

面向对象（objectoriented programming ）缩写OOP

面向对象就是以分类的方式将问题分开处理，的以更加明确的处理问题，这是更倾向于人类思考问题的方式。

面向过程适合于处理简单的问题，直接关注流程，简单有效。

面向对象适合于处理复杂的问题，先使用面向对象的方式对整体关系作出分类，然后，根据不同的类深入细节的处理。

面向对象无法取代面向过程，他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过程的思维方式。面向对象如果离开了面向过程，就无法实现真正的落地，成为无源之水。

java类

类就像是一个模板，描述某一类对象的属性和方法。

类是描述某一类客观存在的群体的基本特征的抽象。

类的结构

成员变量：对象的基本属性的描述。

方法：对象的行为。（对象可以做的事情）

构造方法：用于创建一个或多个对象的方法。

内部块：在类的内部声明的类。

块：代码块。

类的定义

package object_Day1;

/**
 * 类的声明格式为:
 * [访问权限修饰符] [修饰符] class 类名{  }
 * 访问权限修饰符：public  default
 * 修饰符：final abstract
 * class用来定义一个类
 * 类名首字母大写 见名知意 驼峰命名法
 */
public class Car {
//    成员变量：   [访问权限修饰符] [修饰符] 数据类型 变量名称 [=值]
    String name; //名称
    String color; // 颜色
    float  price; //价格
    
/*
方法的声明格式为：
[访问权限修饰符] [修饰符]/void 方法名(){
   		代码块;
        [return   返回值;]
     }
}
 */
    public void start(String a){
        this.name = a;
        System.out.println(a+"汽车启动");
    }
    public int add(int a, int b){
        int he = a + b;//  he 局部变量
        return he;
    }

}

java对象

       /*
           创建汽车对象:
              以Car类为模板,
           Car baoma  =  new + Car();  new 关键字+默认构造方法();
                 在内存空间创建一个对象  实际存在的   实例化对象
           Car baoma 以Car类作为类型 声明一个变量 指向内存空间中的具体的对象
               使用baoma变量访问对象中属性,方法

               通过类可以创建无数个对象
         */
              Car baoma  = new Car();
                  baoma.name = "x5";
                  baoma.price = 600000;
                  baoma.color = "红色";

              Car benchi = new Car();
                  benchi.name = "GTR";
                  benchi.price = 700000;
                  benchi.color = "黑色";

                System.out.println(baoma.name);
                System.out.println(baoma.price);
                System.out.println(baoma.color);
                          baoma.start();
                          baoma.run();
                          baoma.stop();

                System.out.println(benchi.name);
                System.out.println(benchi.price);
                System.out.println(benchi.color);
                            benchi.start();
                            benchi.run();
                            benchi.stop();

类中变量

成员变量

成员变量是定义在类中，方法体之外的变量。
成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
成员变量在创建对象的时候会从类中复制一份到对象中。
成员变量可以被类中方法、构造方法和特定类的语句块访问。
成员变量的作用范围为整个类体。

局部变量

在方法、构造方法或者语句块中定义的变量被称为局部变量。
局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。
局部变量在使用前必须初始化赋值。
变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

类变量

类变量：（也叫静态变量）类变量也声明在类中，方法体之外，但必须声明为static类型。

类中的方法

成员方法：成员方法是定义在类中。这种方法在创建对象的时候创建。
语法格式：
修饰符返回值类型/void 方法名 ( 参数列表) {
方法体语句；
[return 返回值]
}

构造方法:用来创建对象的方法

package object_Day1;

/*
构造方法是定义在类中用来创建对象的方法
 */
public class Structural {
    String name;
    int age;
    //构造方法
    public Structural(){
        System.out.println("无参的构造方法");
    }
    //构造方法对对象的成员变量初始化
    public Structural(String n){
        this.name = n;
        System.out.println(name+"的构造方法");
    }
//    方法的重载
    public Structural(String n,int a){
        //数量不同
    }
    public Structural(int a,String n){
        //顺序不同
    }
    public Structural(int n,int a){
        //数据类型不同
    }
    //成员方法
    public void run(String x){
        System.out.println("name="+x);
    }
    //成员方法的重载
    public void run(String x,int a){//数量不同
        System.out.print("name="+x+" ");
        System.out.println("age="+a);
    }
    public void run(int a,String x){//顺序不同
        System.out.print("name="+x+" ");
        System.out.println("age="+a);
    }
    public void run(int x,int a){//数据类型不同
        System.out.print("name="+x+"   ");
        System.out.println("age="+a);
    }
}

类方法：（也叫静态方法）类方法也声明在类中，但必须声明为static类型

方法重载

方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。
调用时，会根据不同的参数表选择对应的方法。
方法重载
同一个类中
方法名相同
参数不同（可以有三方面的不同）
数量不同
类型不同
顺序不同
注意：方法重载跟方法的返回值类型,访问权限没有任何关系

对象与引用

Java 语言中除基本类型之外的变量类型都称之为引用类型。

Java中的对象是通过引用对其操作的.

例如：我们有一个自定义类为Car（汽车类）

class Car{

	String color;       

	String name;

	String model;

}

Car car= new Car();

通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作。

1）右边的“new Car()”，是以Car类为模板,调用Car类的构造函数,在堆空间里创建一个Car类对象。

2）左边的“Car car”创建了一个Car类引用变量。所谓Car类的引用，就是以后可以用来指向Car对象的对象引用。

3）”=”操作符使对象引用指向刚创建的那个Car对象。

我们可以把这条语句拆成两部分：

Car car;

car= new Car();

这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。

基本类型和引用类型的区别

在这里插入图片描述

值传递与引用传递

Java中进行方法调用中传递参数时，参数传递有两种：

值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。

static关键字

static被称为静态，可以用来修饰类的属性,方法,代码块,内部类。

随着类的加载而加载

优先于对象存在

修饰的成员，被所有对象所共享

可不创建对象，直接被类调用

在这里插入图片描述

static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用

在static方法内部只能访问类的static属性，不能访问类的非static属性。

package object_Day2;

public class Ticket {
    static int yu_piao = 10;
    public static void mai(){
        yu_piao--;
        System.out.println("剩余票量"+yu_piao);
    }

    public static void main(String[] args) {
        Ticket.mai();
        Ticket.mai();
        Ticket.mai();
        Ticket.mai();//没有创建对象也可以访问静态方法
    }
}

静态变量和非静态变量的区别？

1.内存分配
静态变量在类程序初始化时，就存在于内存当中,直到它所在的类的程序运行结束时才结束；
非静态变量需要被实例化后才会分配内存。

2.生存周期
静态变量生存周期为程序的存在周期；
非静态变量的存在周期取决于实例化的类的存在周期。

3.调用方式
静态变量只能通过“类.静态变量名”调用，类的实例不能调用；
非静态变量当该变量所在的类被实例化后，可通过实例化的类名直接访问。

4.共享方式
静态变量是全局变量，被所有类的实例对象共享，即一个实例的改变了静态变量的值，其他同类的实例读到的就是变化后的值；
非静态变量是局部变量，不共享，即一个类的不同实例访问的非静态变量可以是不同的值。

5.访问方式
静态成员不能访问非静态成员；
非静态成员可以访问静态成员。

代码块

代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块

实例块：每次创建对象时自动调用

{

//任何符合语法的Java代码

}

静态块：类加载时自动调用，仅一次，与是否创建对象无关。

static {

//任何符合语法的Java代码

}

package object_Day2;

public class Demo {
    static int a = 10;
    {
        System.out.println("成员方法");
    }
    static {
        System.out.println("静态方法");
    }

    public static void main(String[] args) {
        new Demo();
        new Demo();
        new Demo();
        new Demo();

    }
}

包

物理上是文件夹

是用来管理类的

作用

避免类重名

按照不同功能管理类

控制访问权限

package object_Day3;

//import java.util.Date;
//import java.sql.Date;

/**
 * 包就是文件夹
 * 作用是为了管理类 避免类名的重复 可以让一个类名应用多次
 *
 * 全类名 = 包名（类的地址） + 类名
 * 全类名是当一个程序导入多个重名类是用来区分类的
 * 当用全类名的时候便可以不用使用import导入包
 */

public class Demo {
    java.util.Date date = new java.util.Date();
    java.sql.Date dat = new java.sql.Date(1000);
}

包（package）的命名规范：

在包名中，可以使用.号来区分包的级别；包名一般情况下是小写

第一级指该项目的类型，如com,org,gov等，

第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei等

第三级指项目的名称，如：bcms,oa,erp,cms等

第四级指项目模块的名称，如：bean,action,exception等

访问权限修饰符

•Java语言有四个权限访问修饰符，权限从大到小依次为：

1）public ：公共权限修饰类、属性、方法。（可以被任意类访问）

2）protected：受保护的权限修饰属性、方法。（可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。）

3）default：同包权限修饰类、属性、方法。（只能被同包的类访问）

4）private：私有权限修饰属性、方法。（只能在本类中访问）

package object_Day3;

/**
 * public 公共的 修饰类 属性 方法
 * protected 受保护的 修饰属性 方法
 */
public class Demo1 {
    public int a;
    protected int b = 10;
    int c = 10;
    private int d = 10;

    public void add(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);

    }
    public static void main(String[] args) {
        Demo1 a = new Demo1();
        a.add();
    }
}

在这里插入图片描述

巅峰V红尘

关注

0
点赞
踩
0

收藏

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

面向过程和面向对象的设计思想面向过程（procedure oriented programming）缩写POP 面向过程就是分析得出要进行的每一个步骤一步一步的执行。面向对象（objectoriented programming ）缩写OOP 面向对象就是以分类的方式将问题分开处理，的以更加明确的处理问题，这是更倾向于人类思考问题的方式。面向过程适合于处理简单的问题，直接关注流程，简单有效。面向对象适合于处理复杂的问题，先使用面向对象的方式对整体关系作出分类，然后，根据不同的类深
复制链接

扫一扫