[Java视频笔记]day05

面向对象是一种思想，它的出现将复杂的问题变得简单，程序员从以前的执行者变成了现在的指挥者。对象有一定的功能。

面向对象三个特征：封装，继承，多态。

以后开发：其实就是找对象使用，没有对象，就创建一个对象。找对象，建立对象，使用对象，维护对象的关系。

 

类和对象的关系：

类就是对现实生活中事物的描述，对象就是这类事物，实实在在存在的个体。

现实生活中的对象：张三李四。

想要描述：提取对象共性内容。对具体的抽象。描述时，这些对象的共性有：姓名，年龄，性别，学习Java功能。

映射到java中，描述就是class定义的类。具体对象就是对应java在堆内存中用new建立的实体。

//属性对应类中变量，行为对应类中的函数（方法）
//其实定义类，就是在描述事物，就是在定义属性和行为
//属性和行为共同成为类中的成员（成员变量和成员方法）。
class Car
{
	//描述颜色
	String color = "红色";
	//描述轮胎数
	int num = 4;

	//运行行为
	void run()
	{
		System.out.println(color+"  "+num);
	}
}

class  day05
{
	public static void main(String[] args) 
	{
		//生产汽车，在java中通过new操作符来完成
		//其实就是在堆内产生一个实体
		Car c = new Car();//c就是一个类类型变量，记住，类类型变量指向对象
		
		//需求：将已有车的颜色改成蓝色，指挥该对象做事情。在java指挥方式是：对象.对象成员
		c.color = "blue";

		c.run();
	}
}

多个引用指向一个对象.

 

成员变量作用于整个类中。

局部变量作用于函数中，或者语句中。成员变量都有默认值，可以直接参与运算，局部变量不初始化不能参与运算。

在内存中的位置不同：成员变量在堆内存中，因为对象的存在，才在内存中存在。局部变量在栈内存中。

 

匿名对象是对象的简化形式。

Car c = new Car();

c.num = 5;

可以简写为

new Car().num = 5;

前两句调用匿名对象属性没意义，第三句调用匿名对象方法有意义.执行第二句时，第一句在堆内存中产生的对象成垃圾，第三句执行时，第二句产生的对象成垃圾。

 

匿名对象使用方式1：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。如果对一个对象进行多个成员调用，必须给这个对象起个名字。

 

凡是简化的都有局限性。

 

匿名对象使用方式2：可以将匿名对象作为实际参数进行传递。

show(new Car())； 执行完，堆内存中的对象就成垃圾了。

 

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式.

好处：将变化隔离；便于使用；提高重用性；提高安全性。

封装原则：将不需要对外提供的内容都隐藏起来；把属性都隐藏，提供公共方法对其访问。

函数和类都是封装。

 

关键字private :私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数）,私有只在本类中有效。外界对象不可能访问到。

class Person
{
	private int age;
	void speak()
	{
		System.out.println("age = "+age);
	}
}

将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person中提供对应访问age的方式.

class Person
{
	private int age;

	public void setAge(int a)
	{
		age = a;
	}

	public int getAge()
	{
		return age;
	}
	void speak()
	{
		System.out.println("age = "+age);
	}
}

注意：私有仅仅是封装的一种表现形式。private是最小权限.

之所以对外提供访问方式，是因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码健壮性。

class Person
{
	private int age;

	public void setAge(int a)
	{
		if(a > 0 && a < 130)
		{
			age = a;
			speak();
		}
		else
			System.out.println("invalid age");
	}

	public int getAge()
	{
		return age;
	}
	void speak()
	{
		System.out.println("age = "+age);
	}
}

class  day05
{
	public static void main(String[] args) 
	{
		Person p = new Person();
		p.setAge(-23);
	}
}

构造函数：

特点1：函数名与类名相同 2：不用定义返回值类型 3：不可以写return语句

对象一建立，就自动调用与之对应的类的构造函数。

构造函数的作用：可以用于给对象进行初始化。

class Person
{
	Person()
	{
		System.out.println("peer");
	}
}

构造函数小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数

class Person
{
	Person(){}
}

构造函数重载。

class Person
{
	private String name;
	private int age;
	Person()
	{
		System.out.println("A:name = "+name+" , age = "+age);
	}
	Person(String n)
	{
		name = n;
		System.out.println("B:name = "+name+" , age = "+age);
	}
	Person(String n, int a)
	{
		name = n;
		age = a;
		System.out.println("C:name = "+name+" , age = "+age);
	}
	public void cry()
	{
		System.out.println("cry");
	}
}

构造函数和一般函数在写法上有不同。

在运行上也不同。构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给对象添加具备的功能。一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。

 

什么时候定义构造函数？

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

class Person
{
	private String name;
	private int age;
	/*构造代码块
	作用：给对象进行初始化。
	对象一建立就运行，而且优先于构造函数执行
	和构造函数的区别：
	构造代码块是给所有对象进行统一初始化，
	而构造函数是给对应的对象初始化.
	构造代码块中定义的是不同对象共性的初始化内容
	*/
	{
		cry();//即任何人对象一建立就先“哭”
	}

	Person()
	{
		System.out.println("name = "+name+" , age = "+age);
	}
	Person(String n)
	{
		name = n;
		System.out.println("name = "+name+" , age = "+age);
	}
	public void cry()
	{
		System.out.println("cry");
	}

	
}

class  day05
{
	public static void main(String[] args) 
	{
		Person p1 = new Person();
		Person p2 = new Person("sr");
	}
}

运行结果：

cry

name = null , age = 0

cry

name = sr , age = 0

 

 

this关键字：看上去，用于区分局部变量和成员变量同名的情况。

this:就代表本类的对象，代表它所在函数所属对象的引用

简单说，哪个对象在调用this所在的函数，this就代表哪个对象.

Person(String name)
{
	this.name = name;
}

Person p = new Person("sr");

上面的this就代表对象p

this的应用：当定义类中功能函数时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了本类对象，都用this表示。

public boolean compare(Person p)
{
	return this.age == p.age;
}

this语句：用于构造函数之间互相调用.

this语句只能定义在构造函数的第一行.因为初始化要先执行。

class Person
{
	private String name;
	private int age;

	Person(String name)
	{
		this.name = name;
	}
	Person(String name, int age)
	{
		this(name);//调用构造函数
		this.age = age;
	}
}

this(name);//调用构造函数

this.age = age;

两句前后不能调换顺序，this必须在第一行.