面向对象（一）

**本质：**以类的方式组织代码，以对象的方式封装数据。

static

static修饰词所修饰实际上是类的方法或属性，而无static关键词修饰的是在实例化类后，即对象出现后才出现的。

静态方法 \ 非静态方法

非静态方法的调用需要先实例化这个类，再进行调用。

Demo1：

1
2
3
4
5
6
7
8
9
10
package cn.icewindy.test;

public class Demo1 {
	public static void main(String[] args) {
		Demo2 demo2 = new Demo2();
		demo2.out1();//非静态方法的调用1
		new Demo2().out1();//非静态方法的调用2
		Demo2.out2();//这是静态方法的调用
	}
}

Demo2:

1
2
3
4
5
6
7
8
9
10
package cn.icewindy.test;

public class Demo2 {
	public void out1(){
		System.out.println("这是非静态方法调用");
	}
	public static void out2(){
		System.out.println("这是静态方法的调用");
	}
}

提示：

在同一个类中，静态方法不可以直接调用非静态方法，需要先实例化类，非静态方法可以直接互相调用。这是因为静态方法是与类一起加载的，而非静态方法是在类实例化之后才存在的。

参数传递

我们先来看一下值传递和引用传递的定义；

**值传递(pass by value)：**在调用函数时，将实际参数复制一份传递到函数中，这样在函数中对参数进行修改，就不会影响到原来的实际参数。

**引用传递(pass by reference)：**在调用函数时，将实际参数的地址直接传递到函数中。这样在函数中对参数进行的修改，就会影响到实际参数。

在Java中，所有的传递都是值传递。如果参数是基本类型，传递的是基本类型的字面量值的拷贝。如果参数是引用类型，传递的是该参量所引用的对象在堆中地址值的拷贝。

例子：

1
2
3
4
5
6
7
8
9
10
11
public class test {
   public static void main(String[] args) {
      int a = 1;
      System.out.println(a);//out:1
      test.change(a);
      System.out.println(a);//out:1
   }
   public static void change(int a){
      a = 10;
   }
}

再来看第二个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class test {
   public static void main(String[] args) {
      Person person = new Person();
      System.out.println(person.name);//out:null
      test.change(person);
      System.out.println(person.name);//out:IceWindy
   }
   public static void change(Person person){
      person.name = "IceWindy";
   }
}
class Person{
   String name;
}

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。

构造器有两个特点：

  1. 必须与类的名字相同。
  2. 必须没有返回值，也不可以写void。

构造器的作用：

  1. 使用new关键词，实际上是在调用构造器。
  2. 一般用于初始化值。

tip:在IDEA里使用alt+insert，可以快速生成构造器。

例子：

main:

1
2
3
4
5
6
7
8
public class test {
   public static void main(String[] args) {
      classDemo demo1 = new classDemo();//调用的是无参构造
      System.out.println(demo1.str);//out:null
      classDemo demo2 = new classDemo("hello world");//调用的是有参构造
      System.out.println(demo2.str);//out:hello world
   }
}

class:

1
2
3
4
5
6
7
8
9
public class classDemo {
   String str;
   //无参构造：若无有参构造，无参构造可以隐式
   public classDemo(){}
   //有参构造：一旦定义了有参构造，无参构造就必须显示定义
   public  classDemo(String aStr){
      this.str = aStr;
   }
}

封装

通常的，我们会让类的内部数据操作细节自己完成，不允许外部干涉，仅留有少量的方法给外部使用。

这时，我们会使用private关键词对对象的属性进行隐藏，仅留下public关键词的方法可以对属性进行操作和查看。

封装之后有什么好处呢：

  1. 提高了程序的安全性，保护数据
  2. 隐藏了代码的实现细节
  3. 统一了接口
  4. 增强了可维护性

例子：

main:

1
2
3
4
5
6
7
8
9
public class test {
   public static void main(String[] args) {
      student Student1 = new student();
      Student1.setName("XiaoMing");
      Student1.setGrade(100);
       
      System.out.println(Student1.getName()+" "+Student1.getGrade());//out:XiaoMing 100
   }
}

student:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package cn.icewindy.test;

public class student {
   private String name;
   private double grade;
    
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public double getGrade() {
      return grade;
   }
   public void setGrade(double grade) {
      this.grade = grade;
   }
}