JAVA 面向对象初级（韩顺平）

判断下列代码的输出结果，答案在七.1

public class objec {
    public static void main(String[] args) {
 
        int a = 4 , b = 5;
        AA z = new AA();
        z.swap(a,b);
        System.out.println("2:" + a + " " + b);

    }
}

class AA{
    public void swap(int a,int b){
        int t = a;
        a = b;
        b = t;
        System.out.println("1:" + a + " " + b);
    }
}

目录

一.引言

二.类和对象的关系

三.类和对象的内存分配机制

四.成员方法

五.成员方法的定义

六.跨类和跨对象的方法调用

七.方法成员的传参机制

---

一.引言

为什么引入类和对象（oop）：根本原因是现有的技术不能完美的解决新的需求

例如：存储两个猫的信息

       // 单独变量解决（不利于数据管理）
        String cat1name = "小白";
        String  cat2name = "小花";

        int cat1age = 3;
        int cat2age = 100;

        String cat1color = "白色";
        String cat2color = "花色";

        // 数组解决(1)（体现不出来数据类型）(2)(难以定位数据)(3)不能体现猫的行为
        String[] cat1 = {"小白","3","白色"};
        String[] cat2 = {"小花","100","花色"};

利用类和对象处理该问题

public class objec {
    public static void main(String[] args) {
//使用oop解决
        //实例化一只猫[创建一只猫对象]
        //1.new.Cat()创建一只猫
        //2.Cat cat1 = new Cat()；把创建的猫赋给cat1
        Cat cat1 = new Cat();
       cat1.name = "小白";
        cat1.age = 10;
        cat1.color = "白色";
        //创建第二只猫
        Cat cat2 = new Cat();
        cat2.name = "小花";
        cat2.age = 100;
        cat2.color = "花色";
    }
}
//定义一个猫类
class Cat{
    //属性
    String name;
    int age;
    String color;
}

二.类和对象的关系

1.类是抽象的，代表一类事务，如人类，猫类

2.对象是具体的，代表一个具体的事务

3.类是对象的模板，对象是类的一个个个体

三.类和对象的内存分配机制

 1.栈：一般存放数据类型（局部变量）

 2.堆：存放对象（Cat cat，数组等）

 3.方法区：常量池（非基本数据类型的常量，如字符串），类加载信息

下列代码在内存中的分配机制

Person p1 = new Person();
p1.age = 10;
p1.name = "小名";
Person p2 = p1;

代码举例

Person a = new Person();
a.age = 10;
a.name = "小明";
person b ;
b = a;
System.out.println(b.age);//小明
b.age = 200;
b = null;//b的指向为空
System.out.println(a.age);//200
System.out.println(b.age);//异常

四.成员方法

在某些情况下，我们需定义成员方法，比如人类：除了有一些属性外，还有一些行为，比如：说话，跑步。这时就要用成员方法才能完成

1.做一到n的累加

public class object{
    public static void main(String[] args){
        Person a = new Person();
        Scanner myscanner = new Scanner(System.in);
        int n = myscanner.Intnext();
        a.cal02(n);       
    }
}
//1.public表示方法公开
//2。void 没有返回值
//3.speak（）： speak是方法名，（）是形参列表
//4.{}方法体： 可以执行代码
class Person{
    public void cal02(int n) {
        int res = 0;
        for (int i = 1; i <= n; i++) {
            res += i;
        }
        System.out.println(res);
    }
}

2.做两数和

Person p1 = new Person();
int m = p1.getsum(2,3);
System.out.println(m);


class Person{
String name;
int age ;
 public int getsum(int num1,int num2){
     int res = num1 + num2;
     return res;
        }

}

方法调用机制

 成员方法的优点

1.提高代码的复用性

2.可以将实现的细节封装起来，然后供其他用户来调用

五.成员方法的定义

访问修饰符  返回数据类型  方法名（形参列表）{//方法体

语句

return 返回值；

}

1.形参列表：表示成员方法输入cal（int a），getsum（int a，int b）

2.返回数据类型：表示成员方法输出，void没有返回值

3.方法主体：表示为了实现某一功能的代码块

4.return语句不是必须的

5.return返回类型需与返回数据类型对应，不能忽略数据类型的自动转换

如返回数据类型是double，return的返回数据类型是int也是可以的

5.方法的定义不能嵌套

6.一个问题可以有多个返回值（可用数组进行返回）

六.跨类和跨对象的方法调用

A a =new A();
a.sayOK();
a.m1();



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

    public void sayOK(){
        print(10);//print的直接调用
        System.out.println("继续执行sayOK");
    }

    public void m1(){
        System.out.println("m1()被调用");
        B b = new B();
        b.hi();
    }
}

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

七.方法成员的传参机制

1.对两个数进行交换

int a = 4 , b = 5;
AA z = new AA();
z.swap(a,b);
System.out.println("2:" + a + " " + b);//4 5


class AA{
    public void swap(int a,int b){
        int t = a;
        a = b;
        b = t;
        System.out.println("1:" + a + " " + b);//5 4
    }
}

传值：形参是对实参的临时拷贝，形参的改变不会对实参造成影响

2.怎么通过方法对实参的变量进行修改，这时候就需要用传址操作，即传送参数地址，或者传送对象

例一

int[] arr = {1,2,3};
B a = new B();
a.test(arr);
for (int i = 0; i <= 2; i++) {
    System.out.println(arr[i]);
}

class B{
    public void test(int[] arr){
        arr[0] = 100;//修改元素
    }
}

例二

Person p = new Person();
B b = new B();
p.age = 10;
b.test200(p);//指向堆中的p.age的地址
System.out.println(p.age);


class Person{
    String name;
    int age;
}

class B{
    public void test200(Person p){
        p.age = 1000;
    }
}

例三

Person p = new Person();
B b = new B();
p.age = 10;
b.test200(p);//指向堆中的p.age的地址
System.out.println(p.age);//输出结果为10

class Person{
    String name;
    int age;
}

class B{
    public void test200(Person p){
        p = null;
    }
}

p = null只是B类中的p指向空，而main中的p没有发生改变

3.克隆对象

 Person p = new Person();
 p.age = 100;
 p.name = "milan";
 MyTools tools = new MyTools();
 Person p2 = tools.copyPerson(p);
 System.out.println(p == p2);//false说明 p与p2处在不同空间


class Person{
    String name;
    int age;
}

class MyTools{
    public Person copyPerson(Person p){
        Person p2 = new Person();
        p2.name = p.name;
        p2.age = p.age;
        return p2;
    }
}