面向对象第2章类使用进阶

面向对象第2章类使用进阶

1、面向对象介绍

1.1、对象

对象：能够看的见摸得着的，能够被具体的描述的一类事务称为对象
人，桌子，电脑
对象：属性和行为 属性：对对象的具体描述
行为：对象的具体动作
人的属性：
身高，体重，年龄，性别
人的行为：打游戏，吃饭

1.2、类

类：将对象的某一特征进行分出来的一个群体我们称为类，这个群体具有相同的属性和行为（方法）
人类：按照性别分为，男生类，女生类
桌子：材质：木桌子，石头桌子
电脑：品牌：联想电脑，小米电脑
类：属性和方法（函数）

1.3、类与对象的关系

类是对象的模板，对象是类的具体实现

2、object类

Object类是Javajava.lang包下的核心类，Object类是所有类的父类，何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类；

2.1、toString方法

​ toString()：取得对象信息，返回该对象的字符串表示

2.2、equals方法

​ equals()：对象比较

String类对象比较 使用的是 equals()方法，实际上String类的equals()方法就是覆写 Object类中的equals()方法

1. ​ 基本数据类型的比较用 == (如： a == 3，b == 4, a == b，比较的是值是否相等）
2. ​ 引用类型数据比较：调用 equals()方法进行比较

3、构造函数和方法重载

开发中经常需要在创建对象的同时明确对象的属性值，比如员工入职公司就要明确他的姓名、年龄等属性信息。

那么，创建对象就要明确属性值，那怎么解决呢？也就是在创建对象的时候就要做的事情，当使用new关键字创建对象时，怎么给对象的属性初始化值呢？这就要学习Java另外一门小技术，构造方法。

那什么是构造方法呢？从字面上理解即为构建创造时用的方法，即就是对象创建时要执行的方法。既然是对象创建时要执行的方法，那么只要在new知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行属性赋值。

3.1、语法

修饰符 构造方法名(参数列表){

}

3.2、构造函数特点

1. 构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。
2. 构造方法名称必须和类型保持一致。
3. 构造方法没有具体的返回值。

class Person {
	// Person的成员属性age和name
	private int age;
	private String name;

	// Person的构造方法，拥有参数列表
	Person(int a, String nm) {
		// 接受到创建对象时传递进来的值，将值赋给成员属性
		age = a;
		name = nm;
	}
}

3.3、构造函数调用

理解构造方法的格式和基本功能之后，现在就要研究构造方法是怎么执行的呢？在创建对象的时候是如何初始化的呢？ 构造方法是专门用来创建对象的，也就是在new对象时要调用构造方法。现在来看看如何调用构造方法。

class Person {
	// Person的成员属性age和name
	private int age;
	private String name;

	// Person的构造方法，拥有参数列表
	Person(int a, String nm) {
		// 接受到创建对象时传递进来的值，将值赋给成员属性
		age = a;
		name = nm;
	}

	public void speak() {
		System.out.println("name=" + name + ",age=" + age);
	}
}

class PersonDemo {
	public static void main(String[] args) {
		// 创建Person对象，并明确对象的年龄和姓名
		Person p2 = new Person(23, "张三");
		p2.speak();
	}
}

述代码演示了创建对象时构造方法的调用。即在创建对象时，会调用与参数列表对应的构造方法。

3.4、默认构造函数

没有学习构造方法之前，我们也可以通过new关键字创建对象，并调用相应的方法，同时在描述事物时也没有写构造方法。这是为什么呢？

在之前学习的过程中，描述事物时，并没有显示指定构造方法，当在编译Java文件时，编译器会自动给class文件中添加默认的构造方法。如果在描述类时，我们显示指定了构造方法，那么，当在编译Java源文件时，编译器就不会再给class文件中添加默认构造方法。

class  Person {
	//如果没有显示指定构造方法，编译会在编译时自动添加默认的构造方法
	//Person(){}  //空参数的默认构造方法
}

​ 在描述事物时，要不要在类中写构造方法呢？这时要根据描述事物的特点来确定，当描述的事物在创建其对象时就要明确属性的值，这时就需要在定义类的时候书写带参数的构造方法。若创建对象时不需要明确具体的数据，这时可以不用书写构造方法（不书写也有默认的构造方法）。

构造方法的细节：
1、一个类中可以有多个构造方法，多个构造方法是以重载的形式存在的
2、构造方法是可以被private修饰的，作用：其他程序无法创建该类的对象。

class Person {
	 int age;
	 String name;

	// 私有无参数的构造方法，即外界不能通过new Person();语句创建本类对象
	public  Person() {
	}

	// 多个构造方法是以重载的形式存在
	Person(int a) {
		age = a;
	}

	Person(String nm, int a) {
		name = nm;
		age = a;
	}
}

3.5、构造函数与一般方法的区别

到目前为止，学习两种方法，分别为构造方法和一般方法，那么他们之间有什么异同呢？

构造方法在对象创建时就执行了，而且只执行一次。

一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。

4、this关键字：

在之前学习方法之间调用时，可以通过方法名进行调用。可是针对构造方法，无法通过构造方法名来相互调用。

构造方法之间的调用，可以通过this关键字来完成。

4.1、构造方法调用格式

​ this(参数列表)

4.2、构造方法的调用

class Person {
	// Person的成员属性
	 int age;
	 String name;

	// 无参数的构造方法
	Person() {
	}

	// 给姓名初始化的构造方法
	Person(String nm) {
		name = nm;
	}

	// 给姓名和年龄初始化的构造方法
	Person(String nm, int a) {
		// 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可
		// 调用其他构造方法，需要通过this关键字来调用
		this.name =nm;
		// 给年龄初始化
		age = a;
	}
}

5、static

当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？

可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

5.1、static特点

1. 被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）

   class Demo {
   	public static int num = 100;
   }
   
   class Test {
   	public static void main(String[] args) {
   		Demo d1 = new Demo();
   		Demo d2 = new Demo();
   		d1.num = 200;
   		System.out.println(d1.num); //结果为200
   		System.out.println(d2.num); //结果为200
   	}
   }
   
   

   被static修饰的成员可以并且建议通过类名直接访问。

   ​ 访问静态成员的格式：

   ​ 类名.静态成员变量名

   ​ 类名.静态成员方法名(参数)

   ​ 对象名.静态成员变量名 ------不建议使用该方式，会出现警告

   ​ 对象名.静态成员方法名(参数) ------不建议使用该方式，会出现警告

   class Demo {
   	//静态成员变量
   	public static int num = 100;
   	//静态方法
   	public static void method(){
   		System.out.println("静态方法");
   	}
   }
   class Test {
   	public static void main(String[] args) {
   		System.out.println(Demo.num);
   		Demo.method();
   	}
   }
   
   

5.2、注意事项

​ 静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区

class Demo {
	//成员变量
	public int num = 100;
	//静态方法
	public static void method(){
		//this.num; 不能使用this/super。
		System.out.println(this.num);
	}
}

同一个类中，静态成员只能访问静态成员

class Demo {
	//成员变量
	public int num = 100;
	//静态成员变量
	public static int count = 200;
	//静态方法
	public static void method(){
		//System.out.println(num); 静态方法中，只能访问静态成员变量或静态成员方法
		System.out.println(count);
	}
}

main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。

5.3、定义静态常量

开发中，我们想在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。

定义格式：

public static final 数据类型 变量名 = 值;

class Company {
	public static final String COMPANY_NAME = "打造前程";
	public static void method(){
		System.out.println("一个静态方法");
	}
}

当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。

System.out.println(Company.COMPANY_NAME); 
Company.method(); // 调用一个静态方法

6、内部类

6.1、什么是内部类

将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

6.2、什么时候使用内部类

在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

class 汽车 { //外部类
	class 发动机 { //内部类
}
}

6.3、内部类的分类

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等

在内部类中可以直接访问外部类的所有成员。

6.4、成员内部类

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

格式：

class 外部类 {

修饰符 class 内部类 {

​ //其他代码

}

}

访问方式

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

成员内部类代码

class Body {//外部类，身体
	private boolean life= true; //生命状态
     public class Heart { //内部类，心脏
	public void jump() {
         System.out.println("心脏噗通噗通的跳")
			System.out.println("生命状态" + life); //访问外部类成员变量
}
}

访问内部类

public static void main(String[] args) {
	//创建内部类对象
	Body.Heart bh = new Body().new Heart();
	//调用内部类中的方法
	bh.jump();
}