Java学习笔记10面向对象和类_20200327

第10章 面向对象编程

01 练习

02 对象和类

面向对象编程和面向过程编程

1. 对象，Object 一台电视机，一辆汽车。 对象有两个特征：状态和行为。
2. 对象将其状态存储在字段（变量）中，并通过方法公开其行为。方法对对象的状态进行操作。
   

例1：

import java.awt.Point;

public class day082 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		//Point是java库中的一个类（复杂类型，引用类型）
		//p对象变量
		//new Point()创建 一个Point类型的对象，并将其引用(地址)复制给对象变量p
		//一个Point类型的对象代表一个点，它的状态(x,y)
		Point p = new Point();
		p.x = 10; //将10赋值给p的x字段（变量），x是实例变量
		p.y = 10;//将10赋值组p的y字段（变量）,y是实例变量
		//toString是一个方法，将以字符串形式返回其当前的状
		System.out.println(p.toString());
				
	}
}


----------------------Console result------------
java.awt.Point[x=10,y=10]

tips:（Point源码）
在方法中，使用了 static的是类变量，

例2：

import java.awt.Point;
import java.util.Date;

public class day082 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		//Point是java库中的一个类（复杂类型，引用类型）
		//p对象变量
		//new Point()创建 一个Point类型的对象，并将其引用(地址)复制给对象变量p
		//一个Point类型的对象代表一个点，它的状态(x,y)
		Point p = new Point();
		p.x = 10; //将10赋值给p的x字段（变量），x是实例变量
		p.y = 10;//将10赋值组p的y字段（变量）,y是实例变量
		//toString是一个方法，将以字符串形式返回其当前的状
		System.out.println(p.toString());
		
		//在p引用的对象上调用move方法，将点移动到2,2
		p.move(2, 3);
		System.out.println(p.toString());
		
		//d是对象变量，它将引有刚创建的对象
		//一个Date对象代表日期
		Date d = new Date();  //注：此处Date导入时选择util这一项
		//toLocaleString将会返回格式化的日期字符串
		System.out.println(d.toLocaleString());
				
	}

}

---------------------------Console result---------------
java.awt.Point[x=10,y=10]
java.awt.Point[x=2,y=3]
2020-3-27 11:45:33//此处为实时时间

例3：

import java.awt.Point;

public class Day083 {
	public static void main(String[] args) {
		//p1和p2是使用同一个类创建出来的两个对象，它们相互独立。
		//类是一种复杂的类型
		//p1和p2的类型一样
		Point p1 = new Point();
		p1.x = 1;
		p1.y = 1;
		System.out.println(p1.toString());
		
		Point p2 = new Point();
		p2.x = 10;
		p2.y = 10;
		System.out.println(p2.toString());
		
		p1.move(2, 2);
		p2.move(20, 20);
		System.out.println(p1.toString());
		System.out.println(p2.toString());
		
	}

}

03 使用自定义类

3.1. 例一

使用static的变量叫做类变量，不使用static的变量叫做实例变量

1. 新建一个Person类

package day08;

public class Person {
	//使用static的变量叫做类变量，不使用static的变量叫做实例变量
	String name; //实例变量，姓史
	char  gender;//实例变量，性别
	int age; //实例变量，年龄
	
	//使用static 的方法叫做类变量，不使用static的变量叫做实例变量
	// 实例方法，自我介绍
	public void showInfo() {
		System.out.println("我叫" + name);
		System.out.println("我的性别是" + gender);
		System.out.println("我今年" + age);
	}
}

2）创建主方法

package day08;

public class Day084 {
	public static void main(String[] args) {
		//p1和p2引用的对象互相独立
		Person p1 = new Person(); //创建一个对象变量p1引用刚创建的对象
		p1.name = "张三";//为p1引用的对象的name字段赋值
		p1.gender = '男';
		p1.age = 20;
		p1.showInfo(); //输出p1引用的对象的信息
		
		Person p2 = new Person(); //创建一个对象变量p2引用刚创建的对象
		p2.name = "李四"; // 为p2引用的对象的name字段赋值
		p2.gender = '女'; //为p2引用的对象的name字段赋值
		p2.age = 21;
		p2.showInfo(); //输出p2引用的对象的信息		
	}
}

---------Console result ---------
我叫张三
我的性别是男
我今年20
我叫李四
我的性别是女
我今年21

3.2

对象是类的实例，类是创建对象的蓝图。

一个类就是一个模板，在上面的例子中， Person类就是一个模板，可以创建很多对象，类决定了对象所能有的状态和行为。
根据Person类的定义，我们可以知道：
由Person类创建的对象拥有name,gender,age三个字段，并且有一个showInfo方法

一个对象就是类的一个实例，上面的例子中使用new Person()创建了一个对象。

状态是对象所有字段的集合。通过在对象上调用方法，可以修改对象的状态。

---

04 成员变量

在类中定义的变量叫做成员变量，成员变量分为两种：静态成员变量（类变量）和非静态成员变量（实例变量）。

静态成员变量是属于类的，通过类名调用，每个类在jvm中只有一个，因此静态成员变量只有一份。

4.1 例一

１.new一个Person类

package day08;

public class Person {
	//使用static的变量叫做类变量，不使用static的变量叫做实例变量
	String name; //实例变量，姓史
	char  gender;//实例变量，性别
	int age; //实例变量，年龄
	
	//类变量
	static int count;
	
	
	
	//使用static 的方法叫做类变量，不使用static的变量叫做实例变量
	// 实例方法，自我介绍
	public void showInfo() {
		System.out.println("我叫" + name);
		System.out.println("我的性别是" + gender);
		System.out.println("我今年" + age);
	}
	
	
	public String getName() {
		return name;
	}	
}

2. 创建其主方法。

package day08;

public class Day085 {
	public static void main(String[] args) {
		Person.count = 0;
		Person.count = 1;
		System.out.println(Person.count);
		
		
		Person p1 = new Person(); //创建一个对象变量p1引用刚创建的对象
		p1.name = "张三"; //为p1引用的对象的name字段赋值
		p1.age = 20;
		
		Person p2 = new Person(); //创建一个对象变量p2引用刚创建的对象
		p2.name = "李四"; //为p2引用的对象的name字段赋值
		p2.age = 21;
	}
}


-----------Console result------------
1

4.2 例二

1. Person类不变

实例变量随对象的创建而创建，随对象的销毁而毁。类变量是在类加载时创建的。

对象和实例变量存储在堆内存中，类和类变量存储在方法区。

---

05 成员方法

成员方法分为两种：静态成员方法（类方法）和非静态成员方法（实例方法）

5.1 例一

1. 新建一个Person类

package day08;

public class Person {
	//使用static的变量叫做类变量，不使用static的变量叫做实例变量
	String name; //实例变量，姓史
	char  gender;//实例变量，性别
	int age; //实例变量，年龄
	
	//类变量
	static int count;
	
	
	//使用static 的方法叫做类变量，不使用static的变量叫做实例变量
	// 实例方法，自我介绍
	public void showInfo() {
		System.out.println("我叫" + name);
		System.out.println("我的性别是" + gender);
		System.out.println("我今年" + age);
	}
	
	
//	public String getName() {
//		return name;
//	}	
	
	public static int getCount() {
		return count;
		
	}	
	
}

2. 创建主方法。

package day08;

public class Day086 {
	public static void main(String[] args) {
		Person.count = 10;
		System.out.println(Person.getCount());
		
		
		Person  p = new Person();
		p.name = "赵六";
		p.age = 25;
		p.gender = '男';
		p.showInfo();
		
		p.count = 11; //类变量也可以通过对象来调用，不推荐
		System.out.println(p.getCount()); //类方法也可以通过对象来调用，不推荐。
				
	}
}

5.2

静态方法可以访问静态变量。
编译时错误，静态方法不能访问非静态变量。

例如下：
Person类

package day08;

public class Person {
	//使用static的变量叫做类变量，不使用static的变量叫做实例变量
	String name; //实例变量，姓史
	char  gender;//实例变量，性别
	int age; //实例变量，年龄
	
	//类变量
	static int count;
	
	
	//使用static 的方法叫做类变量，不使用static的变量叫做实例变量
	// 实例方法，自我介绍
	public void showInfo() {
		System.out.println("我叫" + name);//静态方法可以访问静态变量。
编译时错误，静态方法不能访问非静态变量。
		System.out.println("我的性别是" + gender);
		System.out.println("我今年" + age);
	}

	public static int getCount() {
//		System.out.println(count);//静态方法可以访问静态变量
//		System.out.println(name);//编译时错误，静态方法不能访问非静态变量
		return count;
		
	}		
}

2.主方法

package day08;

public class Day086 {
	public static void main(String[] args) {
		Person.count = 10;
		System.out.println(Person.getCount());
		
		
		Person  p = new Person();
		p.name = "赵六";
		p.age = 25;
		p.gender = '男';
		p.showInfo();
		
		p.count = 11; //类变量也可以通过对象来调用，不推荐
		System.out.println(p.getCount()); //类方法也可以通过对象来调用，不推荐。
		
		
		//类方法是属于类的，使用类方法，不必先创建对象。
		System.out.println(Math.max(2, 3));
						
	}
}

5.3

一个类文件可以有多个类，但是只能有一个public类，并且public类的名称要和文件名相同

package day08;

//一个类文件可以有多个类，但是只能有一个public类，并且public类的名称要和文件名相同
public class Day087 {
	

}


class Foo {

}
 
 
 
class Bar {
	 
 }

06 构造器

当使用new操作符创建类的一个实例时，构造器会被调用。没有构造器不能创建对象。

1. 例一
   构造器
   构造器的名称必须和类的名称相同，并且没有返回值
   public Animal() {} 写不写都一样
   如果提供了一个无参构造器，那么编译器将不会提供默认的构造器

public class Animal {
	String name;
	
	//构造器
	//构造器的名称必须和类的名称相同，并且没有返回值
	//public Animal() {} 写不写都一样
	//如果提供了一个无参构造器，那么编译器将不会提供默认的构造器
	public Animal(){
		 System.out.println("Animal()被调用");
	 }
		
	public static void main(String[] args) {
		Animal a1 = new Animal(); //创建对象会调用构造器
		Animal a2 = new Animal();
		
	}

}

2. 例二

public class Animal {
	String name;
	
	//构造器
	//构造器的名称必须和类的名称相同，并且没有返回值
	//public Animal() {} 写不写都一样
	//如果提供了一个无参构造器，那么编译器将不会提供默认的构造器
//	public Animal(){
//		 System.out.println("Animal()被调用");
//	 }
	
	
	//构造器是用来初始化成员变量的
	public Animal() {
		name = "animal";		
	}
		
	public static void main(String[] args) {
		Animal a1 = new Animal(); //创建对象会调用构造器
		Animal a2 = new Animal(); //创建对象会调用构造器
		System.out.println(a1.name); //animal
		System.out.println(a2.name); //animal		
	}
}

3. 调用无参构造器
   3.1 例一

在这里插入代码片

3.2 例二

public class Animal {
	String name;
	
	//构造器
	//构造器的名称必须和类的名称相同，并且没有返回值
	//public Animal() {} 写不写都一样
	//如果提供了一个无参构造器，那么编译器将不会提供默认的构造器
//	public Animal(){
//		 System.out.println("Animal()被调用");
//	 }
	
	
	//构造器是用来初始化成员变量的
	//构造器可以有参数
	public Animal(String aName) {
		name = "animal";		
	}
		
	public static void main(String[] args) {
//		Animal a1 = new Animal(); //编译错误，调用无参的构造器，但是无参构造器不存在
//		Animal a2 = new Animal(); //编译错误，调用无参的构造器，但是无参构造器不存在
		Animal a1 = new Animal("a1");
		Animal a2 = new Animal("a2");
		System.out.println(a1.name); //animal
		System.out.println(a2.name); //animal		
	}
}

4. 构造器的重载

public class Animal {
	String name;
	
	//构造器
	//构造器的名称必须和类的名称相同，并且没有返回值
	//public Animal() {} 写不写都一样
	//如果提供了一个无参构造器，那么编译器将不会提供默认的构造器
//	public Animal(){
//		 System.out.println("Animal()被调用");
//	 }
	
	
	//构造器是用来初始化成员变量的
	//构造器可以有参数
	public Animal(String aName) {
		name = "animal";		
	}
	
	//构造器是可以重载的
	public Animal() {
		name = "默认的名字";
	}
		
	public static void main(String[] args) {
//		Animal a1 = new Animal(); //编译错误，调用无参的构造器，但是无参构造器不存在
//		Animal a2 = new Animal(); //编译错误，调用无参的构造器，但是无参构造器不存在
		Animal a1 = new Animal("a1");
		Animal a2 = new Animal("a2");
		Animal a3 = new Animal();
		System.out.println(a1.name); //animal
		System.out.println(a2.name); //animal
		System.out.println(a3.name);
		
	}
}

--------Console result------
animal
animal
默认的名字