Java类和对象以及方法

Java面向对象

• 万物皆对象

1.类和对象

1.1 类

• 对象的 特征--------属性 【静态】

颜色（属性）：黄色（属性值）

• 对象的 行为--------方法（对象执行的操作)【动态】

1.2 对象

：由一组属性和方法构成的描述客观事物的一个实体 .

1.3 类和对象的关系

• 类就是具有相同属性和方法的一组对象的集合；

• 类是对象的抽象，对象是类的具体；

• 或者说类是对象的模板，对象是类的实例化或者具体 .

  类是个模板，可以根据该模板创建很多对象。

2. Java类模板

2.1 语法

public class 类名{ // 类的作用域
    // 定义属性部分
    属性1的类型 属性1;
        ……
    属性n的类型 属性n;
    
    // 定义方法部分
    方法1；
        ……
    方法m；        
}

• 编写：

  • 定义类；

  • 编写类的成员变量；

  • 编写类的成员方法（能干啥）；

public class Phone{ 
     //成员变量 
    String brand; 
    int price;
    //成员方法 
    public void call(){ 
        System.out.println("打电话")
    }
    public void sendMessage(){
        System.out.println("发短信")
    }
}

 

2.2 对象的使用

• 创建对象：

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

• 引用对象成员：

  • 引用类属性：对象名.属性;

  • 引用类方法：对象名.方法名();

 

 // 1、类
public class  Human{
        // 成员变量
        String name;
        int age;
​
        // 成员方法
     public String showinfo(){
         String info="我是："+ name +"年龄："+ age;
         return  info;
     }
}
​
// 2、测试类
public class TestHuman {
    public static void main(String[] args) {
        // 创建对象  类名 对象名=new 类名（）；
        Human man1=new Human();
        // 使用对象属性和方法
        // 对象名.属性  对象名.方法（）；
        man1.age=19;
        man1.name="小明";
​
        String s=man1.showinfo();
        System.out.println(s);
    }
}
​

 

2.3 类的方法

方法类似于一个“匣子”，可以完成某个特定的应用程序功能，并返回结果

• 方法定义：

public 返回值类型 方法名(){
    // 方法体
}

// 方法返回值可有也可以没有，返回值只能有一个

一个类中允许出现多个同名但不同参数的方法——方法重载

2.4 方法的调用

• 方法之间允许相互调用，在b类中调用a类的方法时，要先创建a的对象再调用即可；

• 同一个类下的不同方法可以直接调用，用 方法名()，（用自家东西），方法名() 就等价于 this.方法名() ；

 

2.5. 带参方法

// 方法参数可以是多个，用逗号隔开；

// 在传参时注意数据类型和数量要和形参的保持一致。

• 方法定义处，参数叫做形式参数（形参名字随便取），主要约束参数类型；

• 方法调用处，参数叫实际参数（实参名字也可随便取）；

• 实参和形参类型保持一致，名字可不一样也可一样。

方法有没有返回值与方法有没有参数无关

2.6 成员变量和局部变量的不同

• 类中位置不同 ，成员变量在类中方法外，局部变量在方法内部或方法声明上；

• 内存中位置不一样，成员变量在（堆内存） ，局部变量在(栈内存)；

• 作用域不一样，成员变量可以多方法共享，局部变量只有本方法可以使用；

• 生命周期不同，成员变量随着对象的存在而存在，随机对象销毁而销毁

局部变量随着方法调用而存在，随着方法调用结束而销毁；

• 初始化值不一样：成员变量有默认初始化值，局部变量没有初始值，必须先定义，赋值才能使用。

 

2.7 传递参数的类型

• 当参数传递为基本数据类型（String不是基本数据类型）时，参数变化不保留

• 当参数传递为引用数据类型（String，自定义数据类型【可以有属性有方法】，数组，接口，类）时，参数变化会保留

  public class Test{
      public void c1(int num){
          num=num+1;
      }
      public void c1(Student student){// 自定义数据类型
          student.age=student.age+1;
      }
  }
  // 测试类
  Test test=new Test();
  int n=8;// 传参   内存中开辟空间存放
  test.c1(n);// 方法调用（将n=8传递给num）
  // 相当于复制给了num一个值为8；n不受影响，num变为9
  Student student=new Student();
  stu.age=18;// 传参
  test.c2(stu);// 这里就是操作的同一对象stu.age会变为19
  System.out.println(n+" "+ stu.age);
  ​
  /*
  结果为n=8(变化不保留)；
  stu.age=19（变化保留）
  为什么呢？看2.7.1
  */

 

2.7.1 数据在传参时的区别

• 基本数据类型传递的是值；（给别人租另一个房，两人操作互不相干）

• 引用数据类型传递的是地址，操作的是同一个对象；（给别人你房子的住址，别人操作的是你的房）

   

2.7.2 对象数组作参数

​
// 修改成绩
public class ModifyScore {
​
    public void modifyS(Student[] stus){
        // 修改成绩，如果不及格，则加2分
        for (int i = 0; i < stus.length; i++) {
            if (stus[i].score<60){
                stus[i].score+=2;
            }
        }
    }
​
    public void showInfo(Student[] stus){
        // 打印学生成绩
        for (Student student:stus){
            student.showinfo();
        }
    }
​
    public static void main(String[] args) {
​
        ModifyScore  ms=new ModifyScore();
        // main 方法，使用类的方法时必须先new出对象
        // 创建学员数组对象
        Student[] stu=new Student[3];
        Student s1=new Student();// 无参构造方法
        s1.name="张";
        s1.score=49;
​
        Student s2=new Student();
        s2.name="李";
        s2.score=90;
​
        Student s3=new Student();
        s3.name="王";
        s3.score=88;
​
        stu[0]=s1;
        stu[1]=s2;
        stu[2]=s3;
​
        ms.modifyS(stu);// 对象数组作参数
        ms.showInfo(stu);
    }
}
// 学生类
public class Student {
 String name;
 int score;
​
 public void showinfo(){
     System.out.println(name+"成绩："+score);
 }
}

发现上面创建学员数组对象步骤繁琐，一旦属性增加，代码量更大；

我们想到用：

3.1 构造方法重载

作用：对象初始化

访问修饰符 构造方法名（）{
    // 初始化代码
}

1. 无返回值类型；（特别注意！！！！）

2. 方法名与类名相同；

3. 可以指定参数——有参构造

4. 对于无参构造方法，每个类都有默认无参构造方法，一旦手工添加了带参构造方法，那么系统默认的无参构造方法就被覆盖了，如果想使用就必须把它写出来；

 

上面的学生类增加如下代码：

public Student(String name,int score){// 有参构造
     // this 是当前对象
     this.name=name;// 等于号后面这个属性值就是传递的参数
     this.score=score;
 }

Student s1=new Student();
        s1.name="张";
        s1.score=49;
此时就可以等价于：
    Student s1=new Student("张",49);

明显代码简洁了不少！

3.2 普通方法重载

自定义方法重载：

• 同一类下，方法名相同；参数项不同；

• 与返回值、访问修饰符无关

  public int add(int num1,int num2){
        return num1+num2;
    }

  public double add(double num1,double num2){
        return num1+num2;
    }

// 看名字和参数就可以判断了