类和对象

最新推荐文章于 2024-09-01 15:30:33 发布

_妲己

最新推荐文章于 2024-09-01 15:30:33 发布

阅读量143

点赞数

分类专栏： Java基础练习题文章标签： java jvm

本文链接：https://blog.csdn.net/m0_57448314/article/details/126567924

版权

Java基础练习题专栏收录该内容

20 篇文章 1 订阅

订阅专栏

面向对象

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

类和对象的概念：

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

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

创建对象的步骤：

1、创建一个对象

2、实例化一个对象

3、把类实例化

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

为了加深印象：

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

        Person a = new Person();
        a.age = 10;
        a.name = "小明";
        Person b;
        b = a;
        System.out.println(b.name);
        b.age = 200;
        b = null;
        System.out.println(a.age);
        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 )

调用带参数的方法时，一定对应着参数传入相同类型或兼容类型的参数

byte b1 = 1;
byte b2 = 2;
a.getSumAndSub(b1 ,b2);//byte -> int
a.getSumAndSub(1.1 ,1.8);// double ->int ( × )

实参和形参的类型要一致或兼容、个数、顺序必须一致

a.getSumAndSub(100);//个数不一致
a.f3("tom", 10);//ok
a.f3(100, "jack");//实际参数和形式参数顺序不对

方法不能嵌套定义

class AA {
    public void f4() {
 //细节：方法不能嵌套定义
        public void f5() {

        }
    }

    public void f3(String str, int n) {

    }
}

同一个类中的方法调用：直接调用即可

    案例演示：sayOk 调用 print（）

public class Method03 {
    public static void main(String[] args) {
        A a = new A();
        a.sayOk();
    }
}

class A {
    //同一个类中的方法调用 ： 直接调用即可

    public void print(int n) {
        System.out.println("print()方法被调用 n = " + n);
    }

    public void sayOk() { // sayOk 调用 print （直接调用即可）
        print(10);
        System.out.println("继续执行sayOk（）");
    }
}

跨类中的方法A类中调用B类方法：需要通过对象名调用

public static void main(String[] args) {
        A a = new A(); 
        a.m1();
}
class A {
    //同一个类中的方法调用 ： 直接调用即可

    public void m1() {
        System.out.println("m1 () 方法被调用 ");
        //创建B对象，然后再调用方法即可
        B b = new B();
        b.hi();

        System.out.println("m1() 继续执行： ");
    }
}

class B{
    public void hi(){
        System.out.println("B类中的hi（）被执行");
    }
}

结果：

练习1：

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

思路：

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

public class MethodExercise01 {
    public static void main(String[] args) {

        AA a = new AA();
        if (a.isOdd(7)) {
            System.out.println("是奇数");
        } else {
           System.out.println("是偶数");
        }
    }
}

//编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ，返回 boolean
class AA {
    /*思路 ；
     * 1. 方法的返回类型 boolean
     * 2. 方法的名字 isOdd
     * 3. 方法的形参 （int num）
     * 4. 方法体，判断 */

    public boolean isOdd(int num) {
//      第一种写法
        if (num  % 2 !=0 ){
            return true;

        }else {
            return false;
        }
//第二种写法
        return num % 2 != 0;
    }

}

结果：

练习2：

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

思路：
* 1. 方法的返回类型 void
* 2. 方法的名字 print
* 3. 方法的形参 （int row ， int col ， char c ）
* 4. 方法体，循环

public class MethodExercise01 {
    public static void main(String[] args) {

        AA a = new AA();
//        if (a.isOdd(7)) {
//            System.out.println("是奇数");
//        } else {
//            System.out.println("是偶数");
//        }

        //使用 print 方法
        a.print(4,4,'#');
    }
}

//编写类 AA 。有一个方法 : 判断一个数是奇数odd还是偶数 ，返回 boolean
class AA {
    /*思路 ；
     * 1. 方法的返回类型 boolean
     * 2. 方法的名字 isOdd
     * 3. 方法的形参 （int num）
     * 4. 方法体，判断 */

    public boolean isOdd(int num) {
//      第一种写法
//        if (num  % 2 !=0 ){
//            return true;
//
//        }else {
//            return false;
//        }
//第二种写法(不知道什么原因报错)
//        return num % 2 != 0 ? true; false;

        //第三种
        return num % 2 != 0;
    }


    // 根据 行 、 列 、 字符 打印 对应行数和列数的字符
    //比如 : 行： 4    列： 4     字符 # ，则打印相应的效果
    /*思路 ；
     * 1. 方法的返回类型 void
     * 2. 方法的名字 print
     * 3. 方法的形参 （int row ， int col ， char c ）
     * 4. 方法体，循环 */
    public void print(int row, int col, char c) {
        for (int i=0;i<row;i++){
            for (int j=0;j<col;j++){//输出每一行
                System.out.print(c);
            }
            System.out.println();//换行
        }
    }
}

结果：

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

练习：

public class MethodParameter01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
// 创建 AA 对象
        AA1 obj = new AA1();
        obj.swap(a, b);  //调用 swap

        System.out.println("a=" + a + "b=" + b);
    }
}


class AA1 {

    public void swap(int a, int b) {
        System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);
        //完成了 a 和 b 的交换
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);
    }
}

结果：

引用数据类型的传参机制

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

public class MethodParameter02 {
    public static void main(String[] args) {

        BB b = new BB();
        int[] arr = {1, 2, 3};
        b.test100(arr);// 调用方法
        System.out.println("main 的 arr 数组");
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();//换行
    }
}
class BB {
    //看一个案例 : B 类中编写一个方法 teat 100 ，
    // 可以接收 一个数组 ，在方法中修改该数组， 看看 原来的数组是否有变化？
    //
    public void test100(int[] arr) {
        arr[0] = 200;//修改元素
        //遍历数组
        System.out.println("test100的 arr数组");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();//换行
    }

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

结果：

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

public class MethodParameter02 {
    public static void main(String[] args) {

        BB b = new BB();
 
        Person p = new Person();
        p.name = "javk";
        p.age=10;

        b.test200(p);
        System.out.println("main 的p.age ="+p.age);
    }
}

class Person1 {
    String name;
    int age;
}
class BB {
public void test200(Person p) {
            p.age = 10000;//修改对象属性
        }
}

结果：

练习：

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

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

public class MethodExercise02 {
    public static void main(String[] args) {

        Person p = new Person();
        p.name = "milan";
        p.age = 100;
        //创建 tools
        MyTools1 tools1=new MyTools1();
        Person p2 = tools1.copyPerson(p);

        //到此 p he p2 是 Person 对象 ， 但是 是两个独立的对象 ，属性相同
        System.out.println("p 的属性 age ="+ p.age + "名字 " + p.name);
        System.out.println("p 的属性 age ="+ p2.age + "名字 " + p2.name);
        // 这里提示 ： 可以同对象比较 看看是否同为一个对象 hashCode
        System.out.println(p==p2);//false
    }
}

class Person2 {
    String name;
    int age;
}

class MyTools1 {

    public Person copyPerson(Person p) {
        //创建一个新的对象
        Person p2 = new Person();
        p2.name = p.name;//把原来对象的名字赋给 p2 . name
        p2.age = p.age;//把原来对象的年龄赋给 p2 . age

        return p2;
    }
}

结果：

_妲己

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
类和对象

面向对象面向对象类和对象的概念：1. 从概念或叫法上看：成员变量=属性=field （即成员变量是用来表示属性的，授课中，统一叫属性）2. 属性是类的一个组成部分，一般是基本数据类型，也可是引用数据类型（对象、数组）创建对象的步骤：1、创建一个对象2、实例化一个对象3、把类实例化对象内存布局（内存分析图）非常重要！！！为了加深印象：分析一个练习题，并分析画出内存分析图，进行分析在某些情况下我们需要定义成员方法（简称方法）小知识：1. public：表示方法是公开。...
复制链接

扫一扫

专栏目录