类与对象

（1）类就是数据类型，比如Cat（这个数据类型是自己创的）

（2）对象就是一个具体的实例

类和对象的区别与联系

（1）类是抽象的，概念的，代表一类事物，比如人类，猫类..，即它是数据类型

（2）对象是具体的，实际的，代表一个具体事物，即是实例

（3）类是对象的模板，对象是类的一个个体，对应一个实例

类和对象的内存分配机制

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

（2）堆：存放对象

（3）方法区：常量池（常量，比如字符串），类加载信息

Java创建对象的流程简单分析

Person p = new Person();

p.name = "jack";

p.age = 10;

（1）先加载Person类信息(属性和方法信息，只会加载一次)

（2）在堆中分配空间，进行默认初始化

（3）把地址赋给p，p就指向对象

（4）进行指定初始化

属性/成员变量

• 基本介绍

（1）从概念或叫法上看：成员变量 = 属性 = field（字段）

（2）属性是类的一个组成部分，一般是基本数据类型，也可以是引用数据类型。例如： int age 就是属性

细节

（1）属性的定义语法同变量，示例：访问修饰符 属性类型 属性名；

访问修饰符：public，protected，默认，private

（2）属性的定义类型可以为任意类型，包含基本类型或引用类型

（3）属性如果不赋值，有默认值

• 例：猫猫问题

  养了两只猫：一只叫小白，3岁，白色。另一只叫小花，今年100岁，花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入小猫名错误，则显示没有这只猫

import java.util.Scanner;
public class Object01{
     public static void main(String[] args){
    //使用面向对象来解决
    //实例化一只猫【创建一只猫对象】
        Scanner myScanner = new Scanner(System.in);
        String name = myScanner.next();
        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 18;
        cat1.color = "white";
        Cat cat2 = new Cat();
        cat2.name = "小花";
        cat2.age = 100;
        cat2.color = "pink";
        if("小白".equals(name)){
            System.out.println(cat1.name + cat1.age+cat1.color);
        }else if("小花".equals(name)){
            System.out.println(cat2.name+cat2.age+cat2.color);
        }else{
            System.out.println("没有这只猫");
        }
    }
}
class Cat{
    String name;
    int age;
    String color;
}

成员方法

• 基本介绍

  在某些情况，我们需要定义成员方法（简称方法）。比如人类：除了一些属性外，我们还有一些行为比如：可以说话、跑步..，通过学习，还可以做算术题。这时就要用成员方法才能完成

• 快速入门

  （1）添加speak成员方法，输出 我是一个优秀的人

  （2）添加cal01成员方法，可以计算从1+...+100的结果

  （3）添加cal02成员方法，该方法可以接收一个数n，计算从1+...+n的结果

  （4）添加getSum成员方法，可以计算两个数的和

public class Method01{
   public static void main(String[] args){
        //方法使用
        //定义好方法后，记得要调用，否则方法无效
        //先创建对象，然后调用方法即可
        Person p1 = new Person();
        p1.speak();
        p1.cal01();
        p1.cal02(10);
        int returnSum = p1.GetSum(20,30);
        System.out.println("GetSum方法返回的值="+ returnSum);
    }
}
class Person{
    //public表示方法是公开的
    //void:表示方法没有返回值
    public void speak(){
        System.out.println("我是一个优秀的人");
    }
    public void cal01(){
        int sum = 0;
        for(int i = 1;i <= 1000;i++){     
            sum += i;
        }
        System.out.println(sum);
    }
    public void cal02(int n){//(int n) 表示当前有一个形参n，可以接收用户的输入
        int sum = 0;
        for(int i = 1; i <= n;i++){
            sum += i;
        }
        System.out.println(sum);
    }
     public int GetSum(int num1,int num2){//返回的是一个整型 
         int sum = num1+num2;
         return sum;
     }
}

例：打印数组map{{1，2，3}，{1，1，3}，{3，2，4}}

public class Method02{
    public static void main(String[] args){
        int[][] map = {{1,2,3},{1,1,3},{3,2,4}};
        Mytools tools = new Mytools();
        tools.printmathod(map);
    }
}
class Mytools{
    public void printmathod(int[][] map){
        for(int i = 0;i < map.length;i++){
            for(int j = 0;j < map[i].length;j++)
                System.out.print(map[i][j]+" ");
        }
        System.out.println();
    }
}

注意事项

• 返回类型：

（1）一个方法最多有一个返回值

（2）返回类型可以为任意类型，包含基本类型或引用类型

（3）如果方法要求有返回数据类型，则方法中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容

（4）如果方法是void，则方法体中可以没有return语句，或者只写return

• 形参列表：

（1）一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开

（2）参数类型可以为任意类型，包含基本类型或引用类型

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

（4）方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参。实参和形参的类型要一致或兼容、个数、顺序必须一致

• 方法体：

  里面写完成功能的具体语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法。即：方法不能嵌套定义。

• 方法调用：

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

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

  例：

public class MethodDetail01{
    public static void main(String[] args){
        A a = new A();
        a.No();
    }
}
class A{
    public void YesOk(int n){
        System.out.println(n);
    }
    public void No(){
        YesOk(10);//同一个类中的方法调用：直接调用即可
        System.out.println("你真棒");
        B b = new B();//跨类中的方法A类调用B类方法：需要通过对象名调用
        b.jump(20,30);
    }
}
class B{
    public void jump(int a,int b){
        int sum = a+b;
        System.out.println(sum);
    }
}

练习

（1）编写类AA,有一个方法：判断一个数是奇数还是偶数，返回boolean(键盘输入)

（2）根据行、列、字符打印对应行数和列数的字符

import java.util.Scanner;
public class Judgement{
   public static void main(String[] args){
        NewJudge a = new NewJudge();
        Scanner myScanner = new Scanner(System.in);
        int n = myScanner.nextInt();
       boolean b = a.judge(n);
       if(b){//练习（1）
       System.out.println("它是个偶数");
   }else{
    System.out.println("它是个奇数");
   }
       a.print(4,4,'*');//练习（2）
    }
}
class NewJudge{
    public boolean judge(int n){
        return n % 2 == 0;
    }
    public void print(int row,int col,char c){
        for (int i = 1;i <= row;i++){
            for(int j = 1;j <= col; j++){
                System.out.print(c);
            }
        System.out.println();
    }
    }
}

注意

！！！基本数据类型：形参的任何改变不影响实参

！！！对于数组（字符串）来说，传的是地址，形参实参相互影响

传参机制练习

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

public class Copy{
     public static void main(String[] args){
        Person p1 = new Person();
        p1.name = "小白";
        p1.age = 18;
        Mytools tool = new Mytools();
        Person p2 = tool.copyPerson(p1);
        System.out.println("p1的属性 age ="+p1.age+"名字="+p1.name);
        System.out.println("p2的属性 age"+p2.age+"名字="+p2.name);
        System.out.println(p1==p2);
    }
}
class Person{
    String name;
    int age;
}
class Mytools{
    public Person copyPerson(Person p1){
        Person p2 = new Person();
        p2.name = p1.name;
        p2.age = p1.age;
        return p2;
    }
}