(07)Java学习笔记——面向对象01

面向过程——面向过程思想，强调的是过程（动作）。

面向对象——面向对象思想，强调的是对象（实体）,然后由对象去调用功能。

面向对象的特点：

1/面向对象就是一种常见的思想，符合人们的思考习惯。

2/面向对象的出现将复杂的问题简单化。

3/面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

如何才能更符合面向对象思想呢？：

a/有哪些类？

——a/ 呵呵分析有哪些类呢？UML,名词提取法。

b/每个类有哪些东西？

c/类与类之间的关系是什么？

例如：

把大象装进冰箱的分析：

a/ 有哪些类？

大象 冰箱 Demo

b/每个类有哪些东西呢？

大象：进去

冰箱：开门 / 关门

Demo: main方法

c/类与类之间的关系是什么呢？

Demo中使用大象和冰箱类的功能。

代码体现：

class Demo 
{
	public static void main(String[] args) 
	{
		冰箱调用开门方法；
		大象调用装进大象方法；
		冰箱调用关门方法；
	}
}

calss 大象
{
	public static void in()
	{
		System.out.println("装进大象");
	}
}

class 冰箱
{
	public static void open()
	{
		System.out.println("打开冰箱门");
	}

	public static void close()
	{
		System.out.println("关闭冰箱门");
	}
}

面向对象的开发，设计，特征：

a/ 面向对象开发

就是不断的创建对象，使用对象，指挥对象做事。

b/面向对象设计

就是在管理和维护对象之间的关系。

c/面向对象特征：

封装 / 继承  / 多态

——————————————————————————————————————

类 与 对象的关系

类：

Java语言通过类的形式对事物进行描述。

通过两个方面描绘事物：

1/属性 （成员变量）

2/行为 （成员方法）

成员变量 —— 就是事物的属性 （和以前变量的定义是一样的格式，但是微智不同，在类中方法外）

成员方法 —— 就是事物的行为  

定义类其实就是定义类的成员（成员变量和成员方法）

类与对象之间的关系：

类：事物的描述，相关属性和行为的集合，是一个抽象概念。

对象：该类事物的具体表现形式，具体存在的个体。在java中通过new来创建的。

如何定义一个类：

范例：定义一个学生类

//定义一个学生类
calss student
{
	//定义成员变量
	//姓名
	String name;
	//年龄
	int age;
	//地址
	String address;

	//定义成员方法
	//学习
	public void study()
	{
		System.out.println("学生爱学习");
	}

	//吃饭
	public void study()
	{
		System.out.println("学生吃饭");
	}

	//睡觉
	public void sleep()
	{
		System.out.println("学生睡觉");
	}
}

如何使用一个类：

创建对象使用类

格式：

类名  对象名 = new 类名（）；

如何使用成员变量？

格式：

对象名 . 变量名；

如何使用成员方法？

格式：

对象名 . 方法名（参数）；

范例：学生类

//定义一个学生类
class student
{
	//定义成员变量
	//姓名
	String name;
	//年龄
	int age;
	//地址
	String address;

	//定义成员方法
	//学习
	public void study()
	{
		System.out.println("学生爱学习");
	}

	//吃饭
	public void eat()
	{
		System.out.println("学生吃饭");
	}

	//睡觉
	public void sleep()
	{
		System.out.println("学生睡觉");
	}
}

class studentDemo
{
	public static void main(String[] args)
	{
		student s = new student();	//	创建一个学生对象 格式：类名 对象名 = new 类名（）；

		System.out.println(s.name+"----"+s.age+"----"+s.address);	//输出成员初始变量值（使用成员变量 格式：类名.成员名；）

		//给成员变量赋值
		s.name = "阿朱";
		s.age = 18;
		s.address = "解放大街";

		System.out.println(s.name+"----"+s.age+"----"+s.address);	//赋值后输出

		//调用方法
		s.study();	//调用类的方法，格式：类名.方法名();
		s.eat();
		s.sleep();
 	}
}

范例：对“小汽车“的描述：

	/*
	描述小汽车
	分析：
	1/属性：轮胎数，颜色
	2/行为：运行
	*/

class  ObjectDemo
{
	public static void main(String[] args) 
	{
		Car c = new Car();	//在计算机中创建一个car的实例。通过new关键字来创建。Car是一个类（下面定义的用来描述的类）， c就是一个类类型的引用变量，指向了该类的对象。

		c.num=4;		//对对象的变量赋值
		c.color="red";	//对对象的变量赋值
		c.run();	//要使用对象中的内容可以通过  对象.成员 的形式来完成调用。					
		
	}
}

class Car	//通过创建一个类，来描述一个事物。
{
	int num;	//属性：通过函数来定义。函数定义属性。（成员变量）
	String color;

	void run()		//行为：通过函数来定义。函数定义一个功能。（成员函数）

	{
		System.out.println(num+"...."+color);
	}

}

——————————————————————————————————————————————————————————————

成员变量和局部变量的区别：

1/成员变量定义在类中，方法外。
局部变量定义在方法，语句，局部代码块中，只在所属的区域有效。


2/成员变量存在于堆内存的对象中
局部变量存在于栈内存的方法中


3/成员变量随着对象的创建而存在，随着对象的消失而消失
局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。


4/成员变量都有默认初始化值
局部变量没有默认初始化值，必须定于赋值才能使用。

注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

范例：

class VariableDemo_01 
{
	public static void main(String[] args) 
	{
		Variable v = new Variable();

		System.out.println(v.num); //访问成员变量

		v.show();

	}
}

class Variable
{
	int num;	//在类中，方法外变量：成员变量

	public void show()
	{
		int num1=20;	//在方法中的变量，局部变量
		System.out.println(num1);

		int num = 100;
		System.out.println(num);	//局部变量在方法中使用的时候，采用就近原则，所以这个sum=100
	}
}

——————————————————————————————————————

方法的形式参数：

形式参数的问题：

基本类型：形式参数改变不影响实际参数

引用类型：形式参数的改变影响实际参数

如果看到一个方法的形式参数是一个类类型（引用类型），这里其实需要的是该类的对象。

范例：

class Demo
{
	public int sum(int a, int b)
	{
		return a+b;
	}
}

class Student
{	
	public void show()
	{
		System.out.println("学生爱学习");
	}
}

class StudentDemo
{	//如果看到一个方法的形式参数是一个类类型（引用类型），这里其实需要的是该类的对象
	public void method(Student s)	//调用时候，把main方法中的s地址传递到了这里 （Student s = new Student();)
	{
		s.show();
	}
}

class ArgsTest_01 
{
	public static void main(String[] args) 
	{
		//形式参数是基本类型调用
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println("result:"+result);
		System.out.println("---------------------------");

		//形式参数是引用类型的调用
		//需求：要调用StudentDemo类中的Method()方法：
		StudentDemo sd = new StudentDemo();

		//创建学生对象
		Student s=new Student();
		sd.method(s);	//把s的地址给到了这里

	}
}

——————————————————————————————————————————————

匿名对象
没有名字的对象。
new Car();    //匿名对象，其实就是定义对象的简写格式。

匿名对象调用方法格式：

new 类名() . 方法名()

new Car().run();   

当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。

范例：

class Student
{
	public void show()
	{
		System.out.println("我爱学习");
	}
}

class  NoNameDemo_01
{
	public static void main(String[] args) 
	{
		//带名字的对象调用方法
		Student s = new Student();
		s.show();

		System.out.println("---------------------------");

		//匿名对象调用方法
		new Student().show();

	}
}

匿名对象可以作为实际参数传递。

————————————————————————————————————————————————

封装

指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
private  /* 私有 */  //只在本类中有效，外界不能访问。是一个权限修饰符，用于修饰成员（成员变量和成员方法）。只能修饰成员。
私有仅仅是封装的一种体现。


例：private int age;  //用于修饰类里面的成员。

封装的好处：

1/将变化隔离，将属性隔离，用方法来对属性进行可控。
2/便于使用
3/提高重用性
4/提高安全性

封装的原则：

1/将不需要对外提供的内容都隐藏起来
2/把属性都隐藏，对外提供公共访问的方法。

封装范例：

class Student
{
	//定义成员变量
	String name;
	private int age;	//用private 私有修饰成员变量，配合setAge()使用
	
	//定义一个成员方法进行输出
	public void show()
	{
		System.out.println("姓名:"+name);
		System.out.println("年龄:"+age);
	}

	//增加一个逻辑校验方法
	public void setAge(int a)	//对外提供一个公共访问方式，隐藏了属性细节
	{
		if (a>0 && a<120)	//设置Age的范围
		{
			age = a;
		}
		else
		{
			System.out.println("请输入正确的年龄：");
		}
	}

		
}

class	StudentDemo_03  
{
	public static void main(String[] args) 
	{
		Student s = new Student();

		s.name="阿紫";
		s.setAge(44);

		s.show();

	}
}

private的应用：

特点：

a/ 可以修饰成员（包括成员变量和成员方法）

b/ 被private修饰的成员只能在本类中才能访问

最常见的应用：

1/ 把成员变量用private修饰

2/ 提供对应的getXxx()   和 setXxx()方法对外访问

范例：

class Student
{
	//定义成员变量
	private String name;
	private int age;	//用private 私有修饰成员变量，配合setAge()使用
	
	//定义一个成员方法进行输出
	public void show()
	{
		System.out.println("姓名:"+getName());
		System.out.println("年龄:"+getAge());
	}

	//增加一个逻辑校验方法
	public void setAge(int a)	//对外提供一个公共访问方式，隐藏了属性细节  **注意返回值类型
	{
		if (a>0 && a<120)	//设置Age的范围
		{
			age = a;
		}
		else
		{
			System.out.println("请输入正确的年龄：");
		}
	}

	public String getName()	//对外提供一个公共访问方式，隐藏了属性细节   **注意返回值类型
	{
		return name;
	}

	public void setName(String b)	//对外提供一个公共访问方式，隐藏了属性细节  **注意返回值类型
	{
		name =b;
	}

	public int getAge()	//对外提供一个公共访问方式，隐藏了属性细节  **注意返回值类型
	{
		return age;
	}
}

class	StudentDemo_03  
{
	public static void main(String[] args) 
	{
		Student s = new Student();

		s.setName("阿朱");
		s.setAge(25);

		s.show();
	}
}

this 关键字

代表当前类的一个对象。 谁调用这个方法，在该方法内部的this就代表谁。

范例：

class Student
{
	//定义成员变量
	private String name;
	private int age;	//用private 私有修饰成员变量，配合setAge()使用
	
	//定义一个成员方法进行输出
	public void show()
	{
		System.out.println("姓名:"+getName());
		System.out.println("年龄:"+getAge());
	}

	//增加一个逻辑校验方法
	public void setAge(int age)	//对外提供一个公共访问方式，隐藏了属性细节  **注意返回值类型
	{
		if (age>0 && age<120)	//设置Age的范围
		{
			this.age = age;	//用this进行当前类对象引用，它就代表当前类的一个对象。
		}
		else
		{
			System.out.println("请输入正确的年龄：");
		}
	}

	public String getName()	//对外提供一个公共访问方式，隐藏了属性细节   **注意返回值类型
	{
		return name;
	}

	public void setName(String name)	//对外提供一个公共访问方式，隐藏了属性细节  **注意返回值类型
	{
		this.name =name;
	}

	public int getAge()	//对外提供一个公共访问方式，隐藏了属性细节  **注意返回值类型
	{
		return age;
	}
}

class	StudentDemo_03  
{
	public static void main(String[] args) 
	{
		Student s = new Student();

		s.setName("阿朱");
		s.setAge(25);

		s.show();
	}
}

练习01：一个手机类

/*
手机类：
成员变量：
品牌： String brand;
价格：int price;
颜色： String color;

成员方法：
针对每一个成员变量给出对应的set() 和 get() 方法。

输出：
创建一个对象，通过get()方法输出成员变量的值，这一次结果是：null----0----null
然后通过set()方法给成员变量赋值，再次输出结果，这次的结果是：小米----1999----土豪金

*/

class Photo
{
	private String brand;
	private int price;
	private String color;

	public void setBrand(String brand)
	{
		this.brand = brand;
	}

	public void setPrice(int price)
	{
		this.price = price;
	}

	public void setColor(String color)
	{
		this.color = color;
	}

	public String getBrand()
	{
		return brand;
	}

	public int getPrice()
	{
		return price;
	}

	public String getColor()
	{
		return color;
	}

}


class  PhotoTest_01
{
	public static void main(String[] args) 
	{
		Photo p = new Photo();
		System.out.println(p.getBrand()+"----"+p.getPrice()+"----"+p.getColor());

		System.out.println("------------------------------");

		p.setBrand("小米");
		p.setPrice(1999);
		p.setColor("土豪金");

		System.out.println(p.getBrand()+"----"+p.getPrice()+"----"+p.getColor());
	}
}

————————————————————————————————————————————————————

构造方法

给对象的数据进行初始化

特点：
1/函数名与类名相同
2/不用定义返回值类型，连void都没有
3/没有具体返回值，不用return返回东西

格式范例：

class Student
{
	public Student()	//构造方法名同类名，且没有返回值类型，
	{
		System.out.println("这是构造方法");
	}
}


class ConstructionDemo 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
	}
}

注意事项和作用：

给对象进行初始化 （创建对象都必须要通过构造函数进行初始化）。
一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

一般函数和构造函数的区别：
1/构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要该函数功能时才调用。
2/构造函数：对象创建时会调用，只会调用一次
一般函数：对象创建时会依据需要调用多次。


什么时候定义构造函数？
在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中。


构造函数的重载：（与函数的重载相似）
可以给不同的对象进行不同的初始化。

class  ConsTest02
{
	public static void main(String[] args) 
	{
		Person p = new Person();	//创建第一个对象，调用相应的初始化构造函数
		p.speak();
		Person p1 = new Person("东东");	//创建第二个对象，调用相应的初始化构造函数
		p1.speak();

		p1.setName("花花");		//可以重复调用Person类中一般函数
		p1.speak();

		Person p2 = new Person("小黑",3);	//创建第三个对象，调用相应的初始化构造函数
		p2.speak();

	}
}

class Person	//定义一个描述人属性的类
{
	private String name;	//将属性私有
	private int age;		//将属性私有

	Person ()				//提供公共借口方法
	{
		name = "baby";
		age = 1;
	}

	Person (String name01)		//相同的函数名，但是不同的参数类型或者参数个数
	{
		name = name01;
	}

	Person (String name02,int age02)	//相同的函数名，但是不同的参数类型或者参数个数
	{
		name = name02;
		age = age02;
	}

	public void setName(String name01)	//一般方法，可重复调用多次，进行不同的参数赋值
	{
		name = name01;
	}

	public void speak()			//创建一个函数描述动作
	{
		System.out.println(name+"...."+age);
	}

}

构造函数可以调用一般方法。一般方法不能调用构造函数。


——————————————————————————————————————————————————————————

类的组成：

A / 成员变量

B / 构造方法

-----| 无参构造方法

-----|带参构造方法

C / 成员方法

-----|setXxx();

-----|getXxx();

_________________________________________________________________________________

练习01：

定义一个类Demo，其中定义一个求两个数据和的方法，定义一个测试类Test,进行测试

class Demo	//定义一个类
{
	public int sum(int x, int y)	//定义类中的一个两数相加的方法
	{
		return x+y;
	}
}

class  Test_001  
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();	//创建一个对象用来调用方法
		
		int result = d.sum(5,8);
		System.out.println(result);
	}
}

什么时候定义成员变量：

如果这个变量是用来描述这个类的信息的，那么该变量就应该定义为成员变量。如果没有关系，就不要定义为成员变量。

变量的范围越小越好，因为能及时被回收。

练习02：

定义一个长方形类，定义求周长和面积的方法，然后测试

class Rectangle_01
{
	private int longside;	//将成员变量私有化
	private int shortside;

	public void setSide(int longside,int shortside)	//提供公共的方法给外部对象调用
	{
		this.longside=longside;
		this.shortside=shortside;
	}

	public Rectangle_01()	//构造函数初始化
	{
	}

	public int meter()	//定义一个计算周长的方法
	{
		int m =(longside+shortside)*2;
		return m;
	}

	public int area()	//定义一个计算面积方法
	{
		int ar = longside*shortside;
		return ar;
	}

}

class RectangleTest_01 
{
	public static void main(String[] args) 
	{
		Rectangle_01 re = new Rectangle_01();	//定义一个对象用来调用方法

		re.setSide(10,5);

		int result1 = re.meter();
		int result2 = re.area();

		System.out.println("长方形的周长是："+result1);
		System.out.println("长方形的面积是："+result2);


	}
}

练习03：

定义一个员工类，分析类成员，给出成员变量，构造方法，get()  set()方法，及显示成员信息的方法。测试

/*
员工的属性：
成员变量：
员工编号，名字，年龄
成员方法：
set()方法给变量赋值
输出员工信息

*/

class Person
{
	private int number;
	private String name;
	private int age;

	public void setNumber(int number)
	{
		this.number = number;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public void setAge(int age)
	{
		this.age = age;
	}

	public void show()
	{
		System.out.println("编号是"+number+"的这个人是"+name+",他的年龄是"+age);
	}

}

class PersonTest_01 
{
	public static void main(String[] args) 
	{
		Person p = new Person();

		p.setNumber(33);
		p.setName("阿朱");
		p.setAge(26);

		p.show();
	}
}

————————————————————————————————————