devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java面向对象1：类、对象、属性（成员变量和局部变量）、方法（方法调用、方法重载、方法重写、构造方法）传值传地址_java对象包括类的属性和方法

作者：一键难忘520 | 2024-08-21 09:17:20

赞

踩

java对象包括类的属性和方法

 开发方法：

结构化开发

● 面向功能划分软件结构

● 自顶向下

● 最小的子系统是方法

● 制约了软件的可维护性和可扩展性

面向对象开发（面向对象程序设计OOP）

● 把软件系统看成各种对象的集合 

● 系统结构较稳定

● 子系统相对独立

● 软件可重用性、可维护性和可扩展性强

1 面向对象

1.1 几个概念（类、对象、属性、方法）

类，指的是将所有实体看为对象，实体共同的部分抽象为类。

        即 具有相同属性和方法的一组对象的集合。（共同特征的描述）

由关键字class修饰，代表一个自定义类。

对象（具体实例）：用来描述客观事物的一个实体，由一组属性和方法构成。

属性：对象具有的各种特征（静态的）。每个对象的每个属性都拥有特定值。

方法（method）：对象执行的操作，是程序中最小的执行单元。方法里的代码要么全都执行，要么全都不执行。

重复的代码或具有独立功能的代码可以抽取到方法中，提高代码的复用性和可维护性。

例：“小狗”这个对象的属性和方法

        属性：颜色（黑色）

        方法：教、跑、吃 

1.2 类和对象的关系

类是对象的抽象，对象是类的具体实现/实例。

类 对象名=new 类();    -------创建对象

对象名.属性、对象名.方法()   -----------访问类的内部，类的属性和方法由对象名. 来调用

2 类 

在Java中，必须先设计类，才能获得对象。

类（设计图）：是对象共同特征的描述。

一个.java文件可以定义多个class类，但只能有一个类由public修饰（主类），且主类名与文件名一致。（实际开发中建议还是一个文件定义一个class类。）

2.1 类的定义

public class 类名{  //  类名首字母建议大写，驼峰模式，要见名知意。

        1. 成员变量（代表属性，一般是名词）

        2. 成员方法（代表行为，一般是动词）

        3. 构造器（后面学习）

        4. 代码块（后面学习）

        5. 内部类（后面学习）

}

类名 对象名 = new 类名(); 

 案例：面向对象-02-类和对象_哔哩哔哩_bilibili

定义一个手机类

  1. public class Phone{// 类名是Phone，全限定类名是 包名.Phone
  2.     // 没有main方法，不能运行
  3.  
  4.     // 属性（成员变量）
  5.     // 一般来说只做声明不做赋值
  6.     String brand;
  7.     double price;
  8.     
  9.     //行为（方法）
  10.     public void call(){
  11.         System.out.println("手机在打电话");
  12.     }
  13.     public void playGame(){
  14.         System.out.println("手机在玩游戏");
  15.     }
  16. }

定义一个测试类 

  1. public class PhoneTest{
  2.     public static void main(String[] args) {
  3.         //创建手机对象
  4.         Phone p = new Phone();
  5.  
  6.         //给手机赋值
  7.         p.brand = "小米";
  8.         p.price = 1999.98;
  9.  
  10.         //获取手机对象的值
  11.         System.out.println(p.brand);
  12.         System.out.println(p.price);
  13.  
  14.         //调用手机中的方法
  15.         p.call();
  16.         p.playGame();
  17.  
  18.         //第二部手机
  19.         Phone p2 = new Phone();
  20.         p.brand = "苹果";
  21.         p.price = 8999;
  22.     }
  23. }

运行结果： 

2.2 JavaBean类

现在我们所学的类，专业术语叫做 Javabean类，是用来描述一类事物的类。面向对象-06-标准的javabean类_哔哩哔哩_bilibili

javaBean类中是不写main方法的，

之前我们所编写的含有main方法的类，叫做 测试类。

3 属性

属性，又叫成员变量、对象变量。

3.1 成员变量

成员变量的完整定义格式：

修饰符 数据类型 变量名称 = 初始化值

一般我们只定义不给值，会有默认值。

类是描述对象的，并不具体，创建对象之后有了特定的对象再给值。

 3.2 局部变量

 局部变量的作用域是该变量被声明的作用域（最贴近的花括号范围）。

 成员变量的作用域是整个类。

3.3 成员变量和局部变量的区别

如果成员变量和局部变量同名，则 变量名指向局部变量（就近原则）

 此时如果要打印成员变量，应该用this.变量名来指向成员变量。

 成员变量有对应类型的默认值，而局部变量没有默认值，如果没有初始化，就会编译报错。

 4 方法

4.1 方法定义的规则

4.2 方法的分类

方法分为有返回值和无返回值方法：

返回值类型为void，表示该方法没有返回值

  • 主要关注执行过程，可以省略return语句不写；
  • 如果要编写return，后面不能跟具体数据。 
    return;//表示结束方法

返回值类型为具体数据类型，表示该方法有返回值

  • 必须有return语句，且return语句返回的值必须能被返回值类型接收，在方法调用处应该有对应的变量接收。 
    return 数据; // 表示结束方法和返回结果

 案例（注意成员变量、成员方法的应用）：

  1. /**
  2.  * 演示加法运算
  3.  */
  4. public class Add {// 类名是Add ，全限定类名是 包名.Add 
  5.     int x;//属性，又叫成员变量、对象变量
  6.     int y;
  7.     public int sum(){//方法，又叫成员方法、对象方法
  8.         return x+y;//有返回值
  9.     }
  10.  
  11.     public static void main(String[] args) {
  12.         Add a=new Add();
  13.         a.x=10;
  14.         a.y=20;
  15.         int res=a.sum();//调用sum（）方法，返回值赋值给res
  16.         System.out.println(res); // 打印res
  17.     }
  18. }

运行结果：

30

4.3 方法的几个注意项

  • return语句下面不能编写代码，因为return表示结束方法，后面的代码永远不会执行到，属于无效代码。
  • 方法和方法之间是平级关系，不能相互嵌套。
  • 方法的编写顺序和执行顺序无关。
  • 方法不调用就不执行。

4.4 方法调用

方法调用：用对象名.方法名(实参列表);  ------实参列表要和形参列表类型完全对应。

方法之间允许相互调用，不需要知道方法的具体实现，实现重用，提高效率。

调用同一个对象的方法：

  1. public class Function {
  2.     void a(){
  3.         System.out.println("这是a方法");
  4.     }
  5.     void b(){
  6.         a();
  7.         System.out.println("这是b方法");
  8.     }
  9.  
  10.     public static void main(String[] args) {
  11.         Function f=new Function();
  12.         f.b();
  13.     }
  14. }

 运行结果：

  1. 这是a方法
  2. 这是b方法

调用不同对象的方法：

  1. public class Function {
  2.     void a(){
  3.         System.out.println("这是a方法");
  4.     }
  5.     void b(){
  6.         a();
  7.         System.out.println("这是b方法");
  8.         Add d=new Add();//成员方法要用对象名字调用
  9.         System.out.println(d.sum());//sum()方法是有返回值的，要么定义一个变量接收返回值，要么直接打印，此为直接打印
  10.     }
  11.  
  12.     public static void main(String[] args) {
  13.         Function f=new Function();
  14.         f.b();
  15.     }
  16. }

运行结果： 

  1. 这是a方法
  2. 这是b方法
  3. 0

4.5 方法重载

方法重载的规则：

1、在同一类中（从父类继承的也算）

2、方法名相同

3、形参列表不同（参数个数不同、参数顺序不同、参数类型不同）

[4、和访问修饰符、返回值类型无关]

好处：定义方法的时候不用太多的单词，减少调用方法时的麻烦

  1. public class Add{
  2.         public static int sum(int a, int b) {
  3.             return a+b;
  4.         }
  5.         public static int sum(int a,int b,int c){
  6.             return a+b+c;
  7.         }
  8.     }

4.6 方法重写@Override

方法重写的规则：（mv 5.4  08.35.22 - 0:53:20）

1、两个类有继承关系

2、方法名相同

3、参数列表相同

4、访问修饰符的范围必须大于等于父类（public>protected>空着不写）

5、返回值类型必须小于父类

6、抛出的异常范围不嫩比父类更严格（异常范围不能扩大）

7、只有被添加到虚方法表中的方法才能被重写

可以被重写的方法都可以称作虚方法 ：不用static、final、private修饰的方法。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         OverseasStudent s = new OverseasStudent();
  4.         s.lunch();
  5.     }
  6.  
  7. }
  8. class Person{
  9.     public void eat(){
  10.         System.out.println("吃米饭，吃菜");
  11.     }
  12.     public void drink(){
  13.         System.out.println("喝开水");
  14.     }
  15. }
  16.  
  17. class OverseasStudent extends Person{
  18.     public void lunch(){
  19.         this.eat();
  20.         this.drink();
  21.  
  22.         super.eat();
  23.         super.drink();
  24.     }
  25.  
  26.     @Override
  27.     public void eat() {
  28.         System.out.println("吃意大利面");
  29.     }
  30.  
  31.     @Override
  32.     public void drink() {
  33.         System.out.println("喝凉水");
  34.     }
  35. }

 运行结果：

  1. 吃意大利面
  2. 喝凉水
  3. 吃米饭，吃菜
  4. 喝开水

重写equals()方法的几个关键点

关于 ==和equals的区别：是否比较地址值

==比较的是地址，equals()是基类Object自带的方法，可以重写它也可以不重写：

没有重写equals()方法时，equals()等同于==。此时比较的是地址。

Java.lang.String重写了equals()方法，把equals()的判断变为了判断其值，equals()就不等同于==了。此时比较的是值（内容）。

（05-04 08.35.22  2:41:00）

1、用instanceof关键字判断类型是否一致

2、类型一致后，用强制类型转换，将一个object类型转成具体类型

                小类型接收大类型，需要强制类型转换

                大类型接收小类型，会默认转换成大类型

        注意: (非基本类型: 小类型和大类型必须有父子关系)

3、根据业务需要、进行判断

instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。

instanceof 是 Java 的保留关键字。它的作用是测试它左边（引用类型所引用的）对象是否是它右边的类的实例，返回 boolean 的数据类型。

4.7 方法重载和重写的区别

重载是为了实现同一个功能的不同场景

重写是多态的基础，为了解决在不同类型中的同一个功能有不同的表现

4.8 构造方法

构造方法也叫构造器、构造函数。面向对象-05-构造方法_哔哩哔哩_bilibili

每一个类都默认有一个来自Object类的空参构造方法，格式如下：

public 类型名() { }   //方法体为空，功能：创建对象

作用：在创建对象的时候给成员变量进行赋值。

特点：1. 方法名与类名相同，大小写也要一致

           2. 没有返回值类型，连void都没有

           3. 没有具体的返回值，不能由return带回结果数据

执行时机：

构造方法是不能手动调用的，而是在创建对象的时候由虚拟机自动调用；

每创建一次对象，就会调用一次构造方法。

构造方法有无参构造和有参构造：

无参构造：初始化的对象时，成员变量的数据均采用默认值

有参构造：在初始化对象的时候，同时可以为对象进行赋值

一旦我们自定义了有参构造，原来的无参构造系统就不再自动提供，

因此在定义有参构造的同时，应该自主 显式的定义无参构造。

public 类型名(形参列表){

        //代码

}

public 类型名() { } 

一旦自定义有参构造后一定要再手动添加一个无参构造！！！

推荐使用的方式：无论是否使用，都手动书写无参构造方法和带全部参数（父类+子类）的构造方法

​​​​​​​有参构造快捷键：Alt+Insert---constructor    或右键Generate---constructor

 调用的时候：类型名 对象名=new 类型名(实参列表);

  1. ​public class Student {
  2.     int stuNo;
  3.     String stuName;
  4.     String gender;
  5.     int age;
  6.     double score;
  7.     public Student(){}//无参构造方法
  8.     public Student(String name,double score){//有参构造方法
  9.         this.name=name;//this代表当前对象，成员变量成员方法都需要用对象名调用，这里的this就代替了对象名
  10.         this.score=score;
  11.     }
  12. }
  13.  
  14. //调用时
  15. Student stu=new Student("张三",80);

 注意以上代码中的this关键字

5 传值和传地址的区别

5.1 传值

基本数据类型之间传递的是值，改变一个变量的值，不会改变另一个变量的值

  1. int a=1;
  2.  
  3. int b=a;
  4.  
  5. b++;//b的值+1，但a的值不会变
  6.  
  7. ----------------------------------
  8.  
  9. public class A(int num){
  10.     num=num+1;
  11. }
  12.  
  13. int a=4;
  14. A(a);
  15. System.out.println(a);//此时a的值还是4

5.2 传地址

引用类型的变量传递的是地址（对象的引用），修改一个对象中的属性值，会同步到其他引用中

  1. Student a=new Student();
  2.  
  3. Student b=a;
  4.  
  5. b.age=10;//此时a.age也是10
  6.  
  7. b=new Student();
  8.  
  9. b.age=18;//此时因为地址改变，不会影响到a.age

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号