Java系列课程笔记-Days11类和对象

Days11类和对象

类

特征：

​ 一类相同或者相近事物的抽象, 看不见摸不着的不存在的事物

​ 是一个模板，可以用类来创建一个或者多个对象

​ 创建 class来标注一个类

​ 基本语法：

​ class 类名{

​ // 属性1；

​ String breed;

​ // 属性2；

​ int age;

​ // 属性3；

​ boolean sex;S

​

​ // 方法1

​ public void eat(){

​ Sout(“eat”);

​ }

​ // 方法2

​ public void sleept(){

​ Sout(“sleep”);

​ }

​ }

package com.james;

public class Dog {

	//	定义了Dog狗的四个属性
	//	属性一般都是名词，用来描述类的特征
	String breed;
	int age;
	String furColor;
	boolean sex;
	
	//	定义吃的方法
	//	方法一般对应的都是对象所具有的行为，一般都是动词或者动宾短语
	public void eat() {
		System.out.println("----------------");
		System.out.println(".....eatting....");
		System.out.println("----------------");
	}
	
	//	定义"睡"的方法
	public void sleep() {
		System.out.println("++++++++++++++++");
		System.out.println("....sleeping....");
		System.out.println("zzzzzzzzzzzzzzzz");
		System.out.println("++++++++++++++++");
	}
}

对象

​ 对象是类的具体体现，每个对象包含各自的属性和方法

​ 一个类可以产生多个对象

​ 类 对象名 = new 类的构造器();

package com.james;

public class DogTest {

	public static void main(String[] args) {
		int[] nums = new int[10];
		
		//	通过类来创建对象
		//	基本语法：类 对象名 = new 类的构造器();
		Dog d1 = new Dog();
		
		//	给每个类的对象的属性赋值
		d1.breed = "二哈";
		d1.sex = true;
		d1.age = 5;
		d1.furColor = "black-white";
		
		//	可以直接通过对象的属性名来获取该对象的该属性的属性值
		System.out.println(d1.breed);
		System.out.println(d1.sex);
		System.out.println(d1.age);
		System.out.println(d1.furColor);
		
		System.out.println("''''''''''");
		
		//	通过对象名的方法名（）来实现对于该对象的方法的调用
		//	方法的调用一定不要忘记方法标志括号，哪怕没有参数，也要写完整的括号
		d1.eat();
		d1.sleep();
	}

}

实例变量与局部变量的对比

1. 定义位置：
   1. 实例变量在类中，方法以外
   2. 局部变量在方法以内或者是某个代码块以内
2. 默认值
   1. 实例变量默认值为该值的零值
   2. 局部变量没有默认值，所以在使用之前必须手动做初始化工作
3. 使用范围
   1. 实例变量在整个类中均可以使用
   2. 局部变量只能在这个方法从声明到方法结束，或者从声明到这个代码块结束
4. 命名冲突
   1. 局部变量不允许与其他的局部变量命名冲突
   2. 实例变量不能与其他实例变量命名冲突，但是可以与局部变量命名重名，最终命名采用“就近原则”

方法的重载

同一个类中的多个同名方法，因为参数的不同，而导致方法的执行过程不一致

特点：

​ 方法名相同

​ 参数列表不同：（个数不同，顺序不同，类型不同）

package com.james;

/**
 * 方法重载有两个要求：
 * 	1.	方法名同名
 * 	2.	方法的参数列表不同
 * 		个数不同
 * 		顺序不同（注意int a, int b与int b， int a是一个效果，不能同时存在，否则编译报错）
 * 		类型不同
 * @author james
 *
 */
public class TestOverLoad01 {

	public int add(int a, int b) {
		return a + b;
	}

	/**
	 * 并不满足重载的规则
	 * 	目前方法的效果和int a，int b两个参数是同一个效果
	 * @param b
	 * @param a
	 * @return
	 */
//	public int add(int b, int a) {
//		return a + b;
//	}

	public double add(double a, double b) {
		return a + b;
	}

	public double add(double a, int b) {
		return a + b;
	}

	public double add(int a, double b) {
		return a + b;
	}

	/**
	 * 方法的重载是不理会方法的返回值类型的，不能以方法的返回值来区分调用不同的方法
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
//	private long add(int a, double b, int c) {
//		return (long)(a + b);
//	}
	
	/**
	 * 方法的重载是不理会方法的修饰符的
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	public long add(int a, double b, int c) {
		return (long)(a + b);
	}

	public int add() {
		return 0;
	}

	public int add(int a) {
		return a;
	}

	public int add(int a, int b, int c) {
		return a + b + c;
	}
	
}

构造方法

package com.james;

/**
 * 构造方法是一个类中的特殊方法，目的是用来创建对象并完成对象的初始化功能的
 * 	特点：
 * 		方法名与类名完全相同（包括大小写）
 * 		构造方法必须没有返回值类型
 * 		如果没有显式地定义构造器，则java编译器会提供一个默认的无参的构造方法
 * 		如果显式地定义了一个构造器，那么java编译器不再提供无参构造器
 * 
 * 	构造方法无法与实例方法实现重载
 * @author james
 *
 */
public class Person {
	
	/**
	 * 构造方法
	 */
	public Person() {}
	
	/**
	 * 普通的实例方法，并不能创建对象，如果想要完成对于该方法的调用，则需要通过Person的对象来调用
	 */
	public void Person(){
		System.out.println("this is person method.");
	}
	
	/**
	 * 不是构造方法，构造方法的方法名与类名完全相同，而且不能有返回值，void也不行，void本身就是一种返回值类型
	 * @param name
	 */
	public void person(String name) {}

	double height;
	double money;
	String face;
	String name;
	boolean sex;
	
	
	public void detail() {
		System.out.println("height:\t" + height);
		System.out.println("money:\t" + money);
		System.out.println("face:\t" + face);
		System.out.println("name:\t" + name);
		System.out.println("sex:\t" + (sex ? "boy":"girl"));
	}
	
	public void work() {
		System.out.println("coding....");
	}
	
	public void life() {
		System.out.println("singing....");
		System.out.println("jump....");
		System.out.println("rap....");
		System.out.println("basket....");
	}
}

构造方法的重载

1. 满足构造方法

   1. 方法名必须与类名完全相同
   2. 方法必须没有返回值类型，void也不行

2. 满足方法重载

   1. 一个类中的多个不同的方法
   2. 方法名相同
   3. 参数列表不同（个数、顺序和类型）

3. 构造方法的重载

   1. 方法名都必须与类名完全相同
   2. 方法必须没有返回值类型
   3. 方法的参数列表各不相同（个数、顺序和类型）

   Point.java

package com.james;

/**
 * 当前类中同时定义了四个构造器
 * 	分别是无参，一参、两参和三参
 * 	这四个构造器形成了构造方法的重载
 * 		方法名都是类名
 * 		方法均没有返回值类型
 * 		方法的参数列表各不相同
 * @author james
 *
 */
public class Point {

	int x;
	int y;
	int z;

	/**
	 * 无参构造器
	 */
	public Point() {
		System.out.println("this is a constructor without params.");
	}

	/**
	 * 一个x参数构造器
	 */
	public Point(int x) {
		System.out.println("this is a constructor x param.");
		this.x = x;
	}

	/**
	 * x和y两个参数构造器
	 */
	public Point(int x, int y) {
		System.out.println("this is a constructor x, y param.");
		this.x = x;
		this.y = y;
	}

	/**
	 * x, y和z三个参数的构造器
	 */
	public Point(int x, int y, int z) {
		System.out.println("this is a constructor x, y, z param.");
		this.x = x;
		this.y = y;
		this.z = z;
	}

	/**
	 * 得到Point对象的详细信息
	 * 
	 */
	public String detail() {
		return "(" + x + ", " + y + ", " + z + ")";
	}
}

TestPoint.java

package com.james;

public class TestPoint {

	public static void main(String[] args) {
		//	使用无参构造器来创建Point对象
		Point p1 = new Point();
		
		System.out.println(p1.detail());
		
		System.out.println("============");

		//	使用一参构造器来创建Point对象，将10给了x
		Point p2 = new Point(10);
		
		System.out.println(p2.detail());
		
		System.out.println("============");

		//	使用两参构造器来创建Point对象，将10给了x， 20给了y
		Point p3 = new Point(10, 20);
		
		System.out.println(p3.detail());
		
		System.out.println("============");

		//	使用三参构造器来创建Point对象，将10给了x， 20给了y， 30给了z
		Point p4 = new Point(10, 20, 30);
		
		System.out.println(p4.detail());
	}
}

最终的运行结果如下：

this is a constructor without params.
(0, 0, 0)
============
this is a constructor x param.
(10, 0, 0)
============
this is a constructor x, y param.
(10, 20, 0)
============
this is a constructor x, y, z param.
(10, 20, 30)

构造方法的调用

在构造方法内可以调用其他的构造方法

可以使用this关键字来调用， this(x)参数x可能是无参，一参或者多参，注意不能写成this.(x)

在构造器内部调用其他的构造方法，该调用语句必须写在代码的非注释的第一行

要注意避免出现递归构造。

package com.james;

/**
 * 当前类中同时定义了四个构造器
 * 	分别是无参，一参、两参和三参
 * 	这四个构造器形成了构造方法的重载
 * 		方法名都是类名
 * 		方法均没有返回值类型
 * 		方法的参数列表各不相同
 * @author james
 *
 */
public class Point02 {

	int x;
	int y;
	int z;

	/**
	 * 无参构造器
	 */
	public Point02() {
		this(0, 0, 0);
		System.out.println("this is a constructor without params.");
	}

	/**
	 * 一个x参数构造器
	 */
	public Point02(int x) {
		//this();
		System.out.println("this is a constructor x param.");
		this.x = x;
	}

	/**
	 * x和y两个参数构造器
	 */
	public Point02(int x, int y) {
		this(x);
		System.out.println("this is a constructor x, y param.");
		//this.x = x;
		this.y = y;
	}

	/**
	 * x, y和z三个参数的构造器
	 */
	public Point02(int x, int y, int z) {
		this(x, y);
		System.out.println("this is a constructor x, y, z param.");
//		this.x = x;
//		this.y = y;
		this.z = z;
	}

	/**
	 * 得到Point对象的详细信息
	 * 
	 */
	public String detail() {
		return "(" + x + ", " + y + ", " + z + ")";
	}
	
	public void printXYZ() {
		System.out.println("x:\t" + x);
		System.out.println("y:\t" + y);
		System.out.println("z:\t" + z);
	}
}

面向对象的三大特性

封装

​ 表现：隐藏实现细节，控制对象的修改和访问权限

​ 实现：

​ 让属性私有化，但是同时提供公有的setter和getter完成对于私有属性的设置和取值

​ setter和getter都是方法，那么在方法的内部可以实现对于非法值、恶意值的屏蔽与过滤

package com.james;

public class TestEncapsulation01 {

	public static void main(String[] args) {
		Person02 p01 = new Person02();
		
		p01.name = "zhangsan";
		//p01.age = 18;
		p01.height = 180;
		
		System.out.println("-------------");
		
		Person02 p02 = new Person02();
		
		p02.name = "lisi";
		//p02.age = -10;
		p02.height = 100;
		
	}

}

class Person02{
	String name;
	private int age;
	double height;
	
	public void printDetail() {
		System.out.println("name:\t" + name);
		System.out.println("age:\t" + age);
		System.out.println("height:\t" + height);
	}
}

关于setter和getter

setter设置器

​ 可以在这个方法内部设置属性值，由于setter本身就是方法，可以添加过滤条件

​ 写法是一个无返回值的带有该属性类型参数的 方法，public void setXxx(Xxx x){}

​ 有需要的花，可以在方法内部添加过滤条件

getter取值器

​ 可以在这个方法内部取值

​ 写法是一个带有该属性类型返回值的无参的方法，public Xxx getXxx(){}

​ 注意：标准的boolean类型的getter是以is开头的