• 类和对象

    目录

     对象内存布局（内存分析图）非常重要！！！

    成员方法注意事项和使用细节 

    参数列表

    练习1：

    练习2：

    基本数据类型的传参机制：

    练习：

    练习：

    面向对象

    • java是一门面向对象的语言，在java思想里一切皆对象
    • 面向对象：Object Oriented Programming
    • 面向过程：Procedure Oriented Programming 
    • 面向过程——步骤化
    • 面向过程就是分析出实现需求所需要的步骤，通过函数（方法）一步一步实现这些步骤，接着依次 调用即可。
    • 面向对象——行为化（概念相对抽象 ）
    • 面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成类（类实例化后才是对 象），让对象去解决对应的问题

    类和对象的概念：

    1. 从概念或叫法上看：成员变量=属性=field （即  成员变量是用来表示属性的，授课中，统一叫属性）


    2. 属性是类的一个组成部分，一般是基本数据类型，也可是引用数据类型（对象、数组）

    创建对象的步骤：

    1、创建一个对象

    2、实例化一个对象

    3、把类实例化

     对象内存布局（内存分析图）非常重要！！！

    为了加深印象：

    分析一个练习题，并分析画出内存分析图，进行分析

    1.         Person a = new Person();
    2.         a.age = 10;
    3.         a.name = "小明";
    4.         Person b;
    5.         b = a;
    6.         System.out.println(b.name);
    7.         b.age = 200;
    8.         b = null;
    9.         System.out.println(a.age);
    10.         System.out.println(b.age);

    在某些情况下我们需要定义成员方法（简称方法）

    小知识：

     1. public： 表示方法是公开  
     2. void ：  表示方法没有返回值  
     3.  speak（）： speak 是方法名，（） 形参列表  
     4.  { } 方法体，可以写我们要执行的代码
     5. int : 表示方法执行后，返回一个 int 值 
     6. (int num1 ,int num2) 形参列表，2个形参，可以接收用户传入的两个数
     7. return res：表示 res 的值，返回

    成员方法注意事项和使用细节 

    参数列表

    • 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开 , 比如：
    getSum ( int n1 , int n2 )
    • 参数类型可以为任意类型，包含基本类型或引用类型
    printArr (int [][] map )
    • 调用带参数的方法时，一定对应着参数传入相同类型或兼容类型 的参数
    1. byte b1 = 1;
    2. byte b2 = 2;
    3. a.getSumAndSub(b1 ,b2);//byte -> int
    4. a.getSumAndSub(1.1 ,1.8);// double ->int ( × )
    •  实参和形参的类型要一致或兼容、个数、顺序必须一致
    1. a.getSumAndSub(100);//个数不一致
    2. a.f3("tom", 10);//ok
    3. a.f3(100, "jack");//实际参数和形式参数顺序不对
    • 方法不能嵌套定义 
    1. class AA {
    2.     public void f4() {
    3.  //细节：方法不能嵌套定义
    4.         public void f5() {
    5.  
    6.         }
    7.     }
    8.  
    9.     public void f3(String str, int n) {
    10.  
    11.     }
    12. }
    •  同一个类中的方法调用 ： 直接调用即可
        案例演示：sayOk 调用 print（）
    1. public class Method03 {
    2.     public static void main(String[] args) {
    3.         A a = new A();
    4.         a.sayOk();
    5.     }
    6. }
    7.  
    8. class A {
    9.     //同一个类中的方法调用 ： 直接调用即可
    10.  
    11.     public void print(int n) {
    12.         System.out.println("print()方法被调用 n = " + n);
    13.     }
    14.  
    15.     public void sayOk() { // sayOk 调用 print （直接调用即可）
    16.         print(10);
    17.         System.out.println("继续执行sayOk（）");
    18.     }
    19. }
    •  跨类中的方法A类中调用B类方法：需要通过对象名调用
    1. public static void main(String[] args) {
    2.         A a = new A(); 
    3.         a.m1();
    4. }
    5. class A {
    6.     //同一个类中的方法调用 ： 直接调用即可
    7.  
    8.     public void m1() {
    9.         System.out.println("m1 () 方法被调用 ");
    10.         //创建B对象，然后再调用方法即可
    11.         B b = new B();
    12.         b.hi();
    13.  
    14.         System.out.println("m1() 继续执行： ");
    15.     }
    16. }
    17.  
    18. class B{
    19.     public void hi(){
    20.         System.out.println("B类中的hi（）被执行");
    21.     }
    22. }

    结果：

    练习1：

    编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ，返回 boolean

    思路：

    * 1. 方法的返回类型 boolean
* 2. 方法的名字 isOdd
* 3. 方法的形参 （int num）
* 4. 方法体，判断

    1. public class MethodExercise01 {
    2.     public static void main(String[] args) {
    3.  
    4.         AA a = new AA();
    5.         if (a.isOdd(7)) {
    6.             System.out.println("是奇数");
    7.         } else {
    8.            System.out.println("是偶数");
    9.         }
    10.     }
    11. }
    12.  
    13. //编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ，返回 boolean
    14. class AA {
    15.     /*思路 ；
    16.      * 1. 方法的返回类型 boolean
    17.      * 2. 方法的名字 isOdd
    18.      * 3. 方法的形参 （int num）
    19.      * 4. 方法体，判断 */
    20.  
    21.     public boolean isOdd(int num) {
    22. //      第一种写法
    23.         if (num  % 2 !=0 ){
    24.             return true;
    25.  
    26.         }else {
    27.             return false;
    28.         }
    29. //第二种写法
    30.         return num % 2 != 0;
    31.     }
    32.  
    33. }

    结果：

    练习2：

      根据 行 、 列 、 字符 打印 对应行数和列数的字符
  比如 : 行： 4    列： 4     字符 # ，则打印相应的效果

    思路：
* 1. 方法的返回类型 void
* 2. 方法的名字 print
* 3. 方法的形参 （int row ， int col ， char c ）
* 4. 方法体，循环 
    1. public class MethodExercise01 {
    2.     public static void main(String[] args) {
    3.  
    4.         AA a = new AA();
    5. //        if (a.isOdd(7)) {
    6. //            System.out.println("是奇数");
    7. //        } else {
    8. //            System.out.println("是偶数");
    9. //        }
    10.  
    11.         //使用 print 方法
    12.         a.print(4,4,'#');
    13.     }
    14. }
    15.  
    16. //编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ，返回 boolean
    17. class AA {
    18.     /*思路 ；
    19.      * 1. 方法的返回类型 boolean
    20.      * 2. 方法的名字 isOdd
    21.      * 3. 方法的形参 （int num）
    22.      * 4. 方法体，判断 */
    23.  
    24.     public boolean isOdd(int num) {
    25. //      第一种写法
    26. //        if (num  % 2 !=0 ){
    27. //            return true;
    28. //
    29. //        }else {
    30. //            return false;
    31. //        }
    32. //第二种写法(不知道什么原因报错)
    33. //        return num % 2 != 0 ? true; false;
    34.  
    35.         //第三种
    36.         return num % 2 != 0;
    37.     }
    38.  
    39.  
    40.     // 根据 行 、 列 、 字符 打印 对应行数和列数的字符
    41.     //比如 : 行： 4    列： 4     字符 # ，则打印相应的效果
    42.     /*思路 ；
    43.      * 1. 方法的返回类型 void
    44.      * 2. 方法的名字 print
    45.      * 3. 方法的形参 （int row ， int col ， char c ）
    46.      * 4. 方法体，循环 */
    47.     public void print(int row, int col, char c) {
    48.         for (int i=0;i
    49.             for (int j=0;j//输出每一行
    50.                 System.out.print(c);
    51.             }
    52.             System.out.println();//换行
    53.         }
    54.     }
    55. }

    结果：

    基本数据类型的传参机制：

    练习：

    1. public class MethodParameter01 {
    2.     public static void main(String[] args) {
    3.         int a = 10;
    4.         int b = 20;
    5. // 创建 AA 对象
    6.         AA1 obj = new AA1();
    7.         obj.swap(a, b);  //调用 swap
    8.  
    9.         System.out.println("a=" + a + "b=" + b);
    10.     }
    11. }
    12.  
    13.  
    14. class AA1 {
    15.  
    16.     public void swap(int a, int b) {
    17.         System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);
    18.         //完成了 a 和 b 的交换
    19.         int tmp = a;
    20.         a = b;
    21.         b = tmp;
    22.         System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);
    23.     }
    24. }

    结果：

    引用数据类型的传参机制

    看一个案例 :  B 类中编写一个方法 teat 100 ，可以接收 一个数组 ，在方法中修改该数组， 看看 原来的数组是否有变化？ 会变化

    1. public class MethodParameter02 {
    2.     public static void main(String[] args) {
    3.  
    4.         BB b = new BB();
    5.         int[] arr = {1, 2, 3};
    6.         b.test100(arr);// 调用方法
    7.         System.out.println("main 的 arr 数组");
    8.         //遍历数组
    9.         for (int i = 0; i < arr.length; i++) {
    10.             System.out.print(arr[i] + "\t");
    11.         }
    12.         System.out.println();//换行
    13.     }
    14. }
    15. class BB {
    16.     //看一个案例 : B 类中编写一个方法 teat 100 ，
    17.     // 可以接收 一个数组 ，在方法中修改该数组， 看看 原来的数组是否有变化？
    18.     //
    19.     public void test100(int[] arr) {
    20.         arr[0] = 200;//修改元素
    21.         //遍历数组
    22.         System.out.println("test100的 arr数组");
    23.         for (int i = 0; i < arr.length; i++) {
    24.             System.out.print(arr[i] + "\t");
    25.         }
    26.         System.out.println();//换行
    27.     }

    结论：引用类型传递的是地址（传递也是值 ，但是 值是地址） ， 可以通过形参影响实参！

    结果 ： 

    B类中编写一个方法 test 200 ，可以接收一个 Person（age ，sal ） 对象，在方法中修改该对象属性 ，看看原来的对象是否变化？会变化

    1. public class MethodParameter02 {
    2.     public static void main(String[] args) {
    3.  
    4.         BB b = new BB();
    5.  
    6.         Person p = new Person();
    7.         p.name = "javk";
    8.         p.age=10;
    9.  
    10.         b.test200(p);
    11.         System.out.println("main 的p.age ="+p.age);
    12.     }
    13. }
    14.  
    15. class Person1 {
    16.     String name;
    17.     int age;
    18. }
    19. class BB {
    20. public void test200(Person p) {
    21.             p.age = 10000;//修改对象属性
    22.         }
    23. }

    结果：

    练习：

    编写一个方法 copyPerson ， 可以复制一个Person对象 ，返回复制的对象 （克隆对象）
注意要求得到新对象和原来的对象是两个独立的对象，只是它们的属性相同

    思路：
       1 方法的返回类型 Person
       2 方法的名字 copyPerson
       3 方法的形参 （Person p)
       4.  方法体。创建一个新对象 ，并复制属性 ，返回即可

    1. public class MethodExercise02 {
    2.     public static void main(String[] args) {
    3.  
    4.         Person p = new Person();
    5.         p.name = "milan";
    6.         p.age = 100;
    7.         //创建 tools
    8.         MyTools1 tools1=new MyTools1();
    9.         Person p2 = tools1.copyPerson(p);
    10.  
    11.         //到此 p he p2 是 Person 对象 ， 但是 是两个独立的对象 ，属性相同
    12.         System.out.println("p 的属性 age ="+ p.age + "名字 " + p.name);
    13.         System.out.println("p 的属性 age ="+ p2.age + "名字 " + p2.name);
    14.         // 这里提示 ： 可以同对象比较 看看是否同为一个对象 hashCode
    15.         System.out.println(p==p2);//false
    16.     }
    17. }
    18.  
    19. class Person2 {
    20.     String name;
    21.     int age;
    22. }
    23.  
    24. class MyTools1 {
    25.  
    26.     public Person copyPerson(Person p) {
    27.         //创建一个新的对象
    28.         Person p2 = new Person();
    29.         p2.name = p.name;//把原来对象的名字赋给 p2 . name
    30.         p2.age = p.age;//把原来对象的年龄赋给 p2 . age
    31.  
    32.         return p2;
    33.     }
    34. }

    结果：

  • 相关阅读:
    APC12345
    【黑马程序员】mysql进阶篇笔记
    老知识复盘-SQL从提交到执行到底经历了什么 | 京东云技术团队
    100道护网面试题大全（附答案）
    【Linux】《Linux命令行与shell脚本编程大全 (第4版) 》笔记-Chapter12-结构化命令
    管理内存堆---减少外部碎片
    循环定时请求接口工具类，添加到对应组件中接口处
    论文阅读笔记(二)——Mask R-CNN
    鲸鱼优化算法（Matlab代码实现）
    如何用蓝牙实现无线定位（三）--本地定位显示
  • 原文地址：https://blog.csdn.net/m0_57448314/article/details/126567924