类、对象、方法、包、构造器、this、super、JavaBean

最新推荐文章于 2023-03-10 22:13:02 发布

㈤㈥㈦

最新推荐文章于 2023-03-10 22:13:02 发布

阅读量638

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/weixin_45291606/article/details/103781629

版权

JavaSE 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

文章目录

一、类class的语法格式

* 修饰符 class 类名{
	属性声明；
	方法声明；
}
* 说明：修饰符public： 类可以被任意访问
	类的正文要用{  } 括起来
* 举例：
public class Person{
	public int age；					//声明公有变量
	public	void	showAge（）{	//声明方法showAge( )
					System.out.println(age);
	}
}

public class Person {
//属性，成员变量，类的成员变量可以先声明，不用初始化，类成员变量是有默认值的
	String name;	//姓名，String的默认值是null
	int age;	//年龄，int的默认值是0
	
	//行为，方法，也叫函数
	/**
	 *打印姓名
	 */
	public void showName(){
		//方法的名称如果是多个单词，收个单词的首字母小写，其他字母的首字母大写，这样就想一个驼峰，故称为驼峰命名法
		System.out.println("姓名：" + name);
	}

	/**
	 * 获取年龄
	 * @return
	 */
	public int getAge(){
		//如果是一个有返回值的方法，n那么方法体的最后一行一定是返回相应的数据，使用return关键字，返回的数据类型与方法定义的一致
		return age;
		}
	}

* 语法格式：
	修饰符  类型   属性名 = 初值；
	说明：修饰符public：该属性可以被该类以外的方法访问。
  		修饰符public：该属性可以被该类以外的方法访问。
  		类型：任何基本类型， 如int、boolean或任何类。
* 举例：
 	public class Person{
		private int age;		//声明private私有的，int类型的，名为age的变量；**只能在类的内部使用**
		public String name = "Lila";	//声明public公有的，String类型的，名为name的变量，并赋值；**可以在类的外部使用，即公有变量可以在别的类中被调用。**
	}

Java权限修饰符public、protected、protected、private置于类的成员定义之前，用来限定对象对该类成员的访问权限

修饰符	在同一个类内部使用	在同一个包内部使用	在其子类使用	在任何地方使用
private	Yes	Yes
(缺省)：即不写任何东西	Yes	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

说明：
private int age;
private void getAge(){ }

int age;
void getAge(){ }

public int name;
public void getName(){ }

* 子类： public class PersonChild extends Person4{ }

* 对于class的权限修饰只可以用public和default（缺省）。
	- public类可以在任何地方被访问
	- default类只可以被同一个包内部的类访问
	- 一个java文件中写多个类，只能有一个public class。。。，其他类只能 class。。。缺省的

* 补充：变量的分类：成员变量与局部变量
	 - 在方法体之外，类体内声明的变量称为成员变量。
	 - 在方法体内部声明的变量称为局部变量。
	
1、成员变量：
	实例变量（不以static修饰）   //实例变量就是说在类实例化成对象之后才能使用
	类变量（以static修饰）		//static，意思是静态的，这样的变量不需要类实例化成对象就可以使用，直接可以通过  类名.属性 这样的方式直接调用
						  
2、局部变量：形参（方法签名中定义的变量）    
	如：public void eat(String food){  }    中的String food  即为形参
	方法局部变量（在方法内定义）    如：int i = 0；
	代码局部变量（在代码块内定义）   //局部变量只能在它所属的方法的范围内使用
 - 成员变量
 	成员变量定义在类中，在整个类中都可以被访问
 	成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。
 	成员变量有默认初始值。
 	成员变量的权限修饰符可以根据需要，选择任意一个。
 	
 - 局部变量
  	局部变量只定义在局部范围内，如：犯法内，代码块内等。
  	局部变量存在于栈内存中。
 	作用的范围结束，变量空间会自动释放。
 	局部变量没有默认初始化值，每次必须显示初始化。 //即如 int i = 0；必须包含 = 的过程，不可以直接 int i ； 
 	局部变量声明时不指定权限修饰符。即如：方法里的 int i；等局部变量的声明无需使用指定的public 或是 private

二、对象的创建和使用

从
	 - java类及类的成员
到
	 - java类的实例化，即创建类的对象**
	 - 使用new + 构造器创建一个新的对象；
	 - 使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）；

* 实例化对象的格式  ：		
	如：  Person person = new Person；
	//声明一个Person类型的变量，实例化Person并且给person赋值，赋的值也是Person类型。

public class Test {	//类名的首字母要大写
	public static void main(String[] args){
		//实例化Person类，也就是创建Person对象
//		int i =0;      //这句是变量i的声明
//		String s = "";	//这句是变量s的声明
		//下面声明一个Person类型的变量;
		Person person = new Person(); //即从内存中开辟一块空间，里边存储Person类型的数据
		person.name = "张三";//给person对象的name属性赋值
		person.showName();//对象的方法的调用
		int i = person.getAge();//有返回值的方法，在调用之后 就会有一个值，这个值是方法中return的那部分
		System.out.println(i);
		
		person.age = 11;//给person对象的age属性赋值
		int a = person.getAge();
		System.out.println(a);
	}
}

在这里插入图片描述

/**
 * 学生类
 * @author 32189
 *
 */
public class Student {
	public String name;//姓名
	public int age;//年龄
	public String course;//课程
	public String interest;//兴趣
	
	public void showInfo(){
		System.out.println("姓名：" + name);
		System.out.println("年龄：" + age);
		System.out.println("课程：" + course);
		System.out.println("兴趣：" + interest);
	}
}

public class Test {	//类名的首字母要大写
	public static void main(String[] args){
	Student stu = new Student();
		stu.name = "小明";
		stu.age = 12;
		stu.course = "语文、数学、英语、化学";
		stu.interest = "打球、街舞、唱歌";
		stu.showInfo();		//调用学生类中的showInfo方法打印输出4个值
	}
}

三、方法（method）

* 什么是方法（函数）？
	 1. 方法是类或对象行为特征的抽象，也称为函数。 
	 2. Java里的方法不能独立存在，所有的方法必须定义在类里。

* 修饰符返回值类型 方法名 （参数类型 形参1，参数类型 形参2，.....）{
	程序代码
	return 返回值；
   }
   
* 其中：
	 - 形式参数：在方法被调用时用于接收外部传入的数据变量。
	 - 参数类型：就是改姓氏参数的数据类型。
	 - 返回值：方法在执行完毕后返还给调用它的程序的数据。
	 - 返回值类型：方法在执行完毕后返回给调用它的程序的数据。
	 - 实参：调用方法时实际传递给函数形式参数的数据。

如何理解方法返回值类型为void的情况？

即：在形参没有得到实参的参数传递时，形参不占用内存空间，当实参传递参数给形参时，在内存中开辟一块空间，用于存放传递到形参的实际参数值，当计算结果完成后，return 结果，之后释放形参因实参的传递而开辟的内存空间。  
 * 注意
 - 没有具体返回值的情况，返回值类型用关键字void表示，name该函数中的return语句如果在最后一行可以省略不写。
 - 定义方法时

在这里插入图片描述

 - 方法中不能再定义方法，即：函数中不能再定义函数，只能调用函数。
 - 同一个类中，所有的方法可以直接相互调用，不用new去实例化对象。

四、对象的产生

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面Person以及前面讲过的数组。
初始值，即不赋初值打印出来的东西

成员变量类型	初始值
byte	0
short	0
int	0
long	0
float	0.0F
double	0.0F
char	‘\u0000’(表示为空)
boolean	false
引用类型	null

引用类型，如String，若不给它赋初值，则打印出来null。

匿名对象

* Student s = new Student();  //这种方式是把new的一个对象赋给一个变量。非匿名
* 也可以new的对象直接用，即不赋给一个变量。如下： 
	new Student().showInfo();
* 我们也可以不把new的对象赋给一个变量，而直接调用这个对象的方法。这样的对象叫做匿名对象。
   如：** new Person().shout();**

* 使用情况
	-  如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
	- 我们经常将匿名对象作为实参传递给一个方法调用。

练习：创建类

1、创建一个Person类，其定义如下：

在这里插入图片描述

要求：
（1）创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”，调用showAge()方法显示age值，调用addAge()方法给对象age属性值增加2岁。
（2）创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。


public class Person {
	public String name;
	public int age;
	public int sex;
	
	public void study(){
		System.out.println("studying");
	}
	
	public void showAge(){
		System.out.println("年龄：" + age);
	}
	
	public int addAge(int i){
		age += i;
		return age;
	}
}

Person person = new Person();
		person.name = "lucy";
		person.age = 11;
		person.sex = 0;
		
		person.study();
		
		int a = person.addAge(2);
		System.out.println("a:" + a +"person.age:" + person.age);
		//输出：a:13   p.age:13   说明 当调用 person.addAge(2)时，age的值+2，11+2=13；此时把这个运算完的结果赋值给变量a，有a的值也是13

2、利用面向对象的编程方法，设计类Circle计算圆的面积。

/**
 * 计算圆的面积
 * @author 32189
 *
 */
public class Circle {
	/**
	 * 计算圆的面积
	 * @param r 圆的半径
	 * @return
	 */
	public double area(double r){
		return 3.14 * r * r;
	}
}

public class Test {	//类名的首字母要大写
	public static void main(String[] args){
	double area = new Circle().area(2);
	System.out.println("半径为2的圆面积是：" + area);
	}
}

类的访问机制

* 类的访问机制：
	- 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）
	- 在不同类中的访问机制：要先创建类的对象，再用对象访问类中定义的成员。

五、包----Package

* 类似于文件夹的概念 
	package语句作为java源文件的第一条语句，知名该文件中定义的类所在的包。
	（若缺省该语句，则指定为无名包）。它的格式为：
	package 顶层包名.子包名；
* 举例:
	- 包对应于文件系统的目录，package语句中，用“ ” 来指明包（目录）的层次
	- 包通常使用小写单词，类首字母通常大写
	- 包和文件夹一样可以有多级，即包中可以包含包和文件，
	- 多级包书写格式：如，com包-->cn包-->test包，写法为**com.cn.test**
	- 不同包之间文件的相互调用 利用 **import**关键字 或者 在语句中多层调用 
	- import day06.test.* 或者 import day06.test.变量名，
		(其中*一般import是导入一个jar包中的类路径中的所有的类，不含子子目录里的类)

在这里插入图片描述

六、类的成员之三：构造器（构造方法）

* 构造器的特征
	- 它具有与类相同的名称
	- 它不生命返回值类型。（声明与void不同）
	- 不能被static、final、synchronized、abstract、native修饰，不能return语句返回值
* 构造器的作用：创建对象；给对象进行初始化
	-如：Order o = new Order();  Person p = new Person(Peter,15);
	- 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造方法中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

* 构造器（构造方法）
	- 根据参数不同，构造器可以分为如下两类：
		- 隐式无参构造器（系统默认提供）
		- 显示定义一个或多个构造器（无参、有参）
* 注意：
	- Java语言中，每个类都至少有一个构造器
	- 默认构造器的修饰符与所属类的修饰符一致
	- 一旦定显示定义了构造器，则系统不再提供默认构造器
	- 一个类可以创造多个重载的构造器
	- 父类的构造器不可被子类继承

1、隐式构造器(系统默认)

	//new对象的根本原理？就是通过类的构造方法（构造器），此处为隐式无参构造
	Person p = new Person();
	//怎么new出Person对象？  其实就是调用了 public Person(){ } 方法（隐式构造器）

2、显式构造器(无参)

//若想在Person5 p = new Person5(); 初始化的时候就给age和name一个默认值，则考虑如下写法：
	/**
	 * 如果显示的定义了构造方法，那么就会使用显示的构造，就不会使用默认的了
	 */
	public Person5(){	
		age = 1;
		name = "张三";
	}
	public int age;
	public String name;
	public void showInfo(){
		System.out.println(age);
		System.out.println(name);
	}
	
	//测试类中代码如下：//上述无参的构造器赋予变量一个默认的初始值，在测试类调用打印函数时，只能打印默认初始值，不能改变。
	Person5 p = new Person5();
	p.showInfo();

3、显示构造器（有参）

	//若想在new对象的时候能够自己给属性赋不同的值，该如何做？
	public Person5(int a,String n){
		age = a;
		name = n;
	}//构造器代码结束
	public int age;
	public String name;
	public void showInfo(){
		System.out.println(age);
		System.out.println(name);
	}
	
	//测试类中代码如下：
	Person5 p = new Person5(2,"李四");  //上述有参的构造器可以允许我们自己赋予变量某值。
	p.showInfo();

//默认的构造方法前面有没有访问的修饰符跟定义的类有关；
//类是public的，默认的构造方法就是public；类是缺省的，默认的构造方法就是缺省的

练习:添加构造器

1、在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18；

public class Person {
	  //在Person6 类中添加构造器，利用构造器设置所有人的age属性初始值都为18.
	public Person(){
		age = 18;	
	}//构造器
	public int age;
}

public class Test {
	public static void main(String[] args){
		
		Person6 p = new Person();
		System.out.println(p6.age);
	}		
}

2、修改上题中类和构造器，增加name属性，使得每次创建Person对象的同时初始化对象age属性值和name属性值。

public class Person6 {
	  //
	public Person6(int a, String n){
		age = a;
		name = n;
		
	}//构造器
	
	public int age;
	public String name;
}

public class Test {
	public static void main(String[] args){
		
		Person6 p6 = new Person6(12,"张三");
		System.out.println(p6.age);
		System.out.println(p6.name);
	}		
}

3、定义一个“点”（Point）类用来标识三维空间中的点（有三个坐标）。要求如下：
1）可以生成具有特定坐标的点对象。
2）提供可以设置三个坐标的方法。
（1）

public class Point {
	public Point(int m, int n, int k){//构造器明和类名一致
	x = m;
	y = n;
	z = k;
	}//构造器
	int x;
	int y;
	int z;
}

public class Test {
	public static void main(String[] args){
		
		Person6 p6 = new Person6(12,"张三");
		System.out.println(p6.age);
		System.out.println(p6.name);
		
		Point po = new Point(1,2,3);
	}		
}

（2）

package day06;

public class Point {
	public Point(int m, int n, int k){
	x = m;
	y = n;
	z = k;
	}
	int x;
	int y;
	int z;
	
	public void setPoint(int m, int n, int k){
		x = m;
		y = n;
		z = k;
	}//设置坐标点的方法，通过po.setPoint(6,7,8);调用方法赋予参数
}

public class Test {
	public static void main(String[] args){
		
		Person6 p6 = new Person6(12,"张三");
		System.out.println(p6.age);
		System.out.println(p6.name);
		
		Point po = new Point(1,2,3);//在new对象的时候可以生成具有特定坐标的点对象。
		
		po.setPoint(6,7,8);
	}		
}

4、编写两个类，TriAngle 和 TestTriAngle，其中TriAngle中声明私有的底边长base和高height，同时声明公共方法访问私有变量；另一个类中使用这些公共方法，计算三角形面积。

构造器重载

构造器也叫构造方法，既然是方法，那就可以重载
构造器一般用来创建对象的同时初始化对象。如

class Person{
	String name;
	int age;
	public Person(String n, int a){
		name = n;
		age = a;
	}//构造器
}

构造器的重载，如：
构造器的重载，就是为了方便“调用方”可以灵活的创建出不同需要的对象，重载的多个构造方法实际上就是相当于提供了多个初始化new对象的模板

public class Person6{

	public Person6(){
	
	}//构造器1
	public Person6(int a){
	
	}//构造器2

	public Person6(String n){

	}//构造器3

	public Person6(int a, String n){
		//age = 18;
		age = n;
		name = m;
	}
}

构造器重载的使用：

	new Person6();
	new Person6(1);
	new Person6("ss");
	new Person6(1,"ss");

写重载的作用：为了应对不同的局面
因为创建对象的时候，可能有多种不同类型的需要创建的对象

七、关键字–this

* this是什么？
	- 在java中，this关键字比较难理解，它的作用和其词义很近似。
  	- 它在方法内部使用，即这个方法所属对象的引用；
  	- 它在构造器内部使用，表示该构造器正在初始化的对象。
	- this表示当前对象，可以调用类的属性、方法和构造器。
	- 什么时候使用this关键字呢？
  	- 当在方法内需要用到调用该方法的对象时，就用this

使用this，调用属性、方法

package day06;

public class Person7 {
	public Person7(int age, String name){	//括号里边是形参
			this.age = age;		//利用this关键字来区分age变量是构造器里的形参还是外面的类成员变量
			this.name = name;	//this.name代表的是外面的类成员变量，name代表的是构造器里的形参
	}//构造器，
	
	int age;
	String name;
	
	public void setName(String name){	//括号里面是形参
		this.name = name;  //形参name的值赋给类成员变量。
	}
	
	public void setName1(String name){
		this.setName(name);//调用当前类的方法,把形参的值传递给setName(){ }方法.
	}
	
	public void showInfo(){
		System.out.println("姓名：" + this.name);//打印的是类Person7的成员变量
		System.out.println("年龄：" + this.age);
	}
}

* 注意：
	1、当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量是 类成员
	2、在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
	3、this(); 可以作为一个类中，构造器相互调用的特殊格式

package day06;

public class Person7 {
	
	public Person7(){
		
	}//构造器2
	
	public Person7(int age){
		this.age = age;
	}//构造器3
	
	public Person7(String name){
		this();		//this();这种方式等同于调用构造方法
		this.name = name;
	}//构造器7
	
	public Person7(int age, String name){	//括号里边是形参
		this(1);   //==此时是调用构造器3里的形参==
		this.age = age;		//利用this关键字来区分age变量是构造器里的形参还是外面的类成员变量
		this.name = name;	//this.name代表的是外面的类成员变量，name代表的是构造器里的形参
	}//构造器1
	
	
	int age;
	String name;
	
	public void setName(String name){	//括号里面是形参
		this.name = name;  //形参name的值赋给类成员变量。
	}
	
	public void setName1(String name){
		this.setName(name);//调用当前类的方法,把形参的值传递给setName(){ }方法.
	}
	
	public void showInfo(){
		System.out.println("姓名：" + this.name);//打印的是类Person7的成员变量
		System.out.println("年龄：" + this.age);
	}
}

* 注意：
 1、使用this()必须放在构造器的首行！
 2、使用this调用本类中其他的构造器，必须必保证至少有一个构造器是不使用this的。
* 如:
	3号构造器中调用了1号构造器中的形参，
	2号构造器中也调用了1号形参，
	此时1号构造器再不可以调用2或3号构造器中形参，
	因为如果1号构造器此时调用了2或3号构造器，
	由于2或3号构造器中已经调用了1号构造器，
	那么此时1号构造器就自己调用了自己，这是不允许的.

八、关键字super

* 在Java类中使用super来调用父类中的指定操作:
	- super可用于访问父类中定义的属性。
	- super可用于调用父类中定义的成员方法。
	- super可用于在子类构造法方法中调用父类的构造器。
* 注意：
	- 尤其当子父类出现同成员时，可用super进行区分。
	- super的追溯不仅限于直接父类使用super.可以调用父类的父类中的成员变量、方法。
	- super和this的用法相像，this代表对象的引用，super代表父类的空间标识。

调用父类的构造器

子类中所有的构造器默认都会访问父类中空参数的构造器
当父类中没有空参数的构造器时，子类的构造器必须通过this（参数列表）或者super（参数列表）语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行。
如果子类构造器中既未显示调用父类或本类的构造器，且父类中有没有无参的构造器，则编译出错。

package day7;

public class ManKind {
//	public ManKind(){
//		System.out.println("ManKind");
//	}无参数的构造器
//	  
//	//当存在显示的构造方法时，类就没有默认的无参构造了，而是要使用显示的构造
//	public ManKind(int sex, int salary){
//		this.sex = sex;
//		this.salary = salary; 
//	}//有参数的构造器,必须在中添加一个有参
	  
	int sex;
	int salary;
	
	//下面设置set、get方法
	public int getSex() {
		return sex;
	}

	public void setSex(int sex) {
		this.sex = sex;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

	public void manOrWomen(){
		if (this.sex == 1)
			System.out.println("man");
		else if(this.sex == 0)
			System.out.println("woman");
	}
	
	public void employeed(){
		if(this.salary == 0)	
			System.out.println("no job");
		else
			System.out.println("job");		
	}
}

package day7;

public class Kids extends ManKind{
	
//	public Kids(int sex, int salary){//
//	//在父类只有有参构造可以使用的时候，子类必须显示的 构建一个构造，来调用父类的有参构造，并且调用父类构造方法要写在第一行
//	super(sex, salary);
//	int i = 1;
//}//有参的构造器

//继承ManKind里的set、salary类成员变量
	
//	public Kids(){
//		super();
//	}


	 int yearsOld;//封装隐藏后set、get  yearsOld方法
	
	public int getYearsOld() {
		return yearsOld;
	}

	public void setYearsOld(int yearsOld) {
		this.yearsOld = yearsOld;
	}

	public void printAge(){
		System.out.println(this.yearsOld);
	}
	
	/**
	 * 重写了父类的employeed方法
	 */
	@Override
		public void employeed() {	
//			System.out.println("Kid should study and no job.");
		//修改练习1.1中定义的类Kids中employed方法，在该方法中调用父类ManKind的employed()方法，
		//然后再输出“but Kinds should study and no job”
		super.employeed();//调用父类ManKind的employed()方法
		System.out.println("but Kids should study and no job.");
		//输出but Kids should study and no job.
	}//重写
	
	public static void main(String[] args){
		Kids someKid = new Kids();//new Kids()是在调用Kids类的默认无参构造方法，在这个过程中就不使用到父类的无参构造
		someKid.setSex(0);
		someKid.setSalary(100);
		
		someKid.manOrWomen();
		someKid.employeed();
	}	
}

package day7;
public class Kk extends Kids{
	public void test(){
		super.salary = 1;//可以使用super向上追溯 父类-父类的成员变量，当然可以一直向上追溯，(如果有那么多个层级的父类的话)
		super.yearsOld = 1;//可以使用super直接追溯使用父类的成员变量
		super.employeed();//可以使用super直接追溯使用父类的成员方法
		super.manOrWomen();//可以使用super向上追溯父类的父类的成员方法，可以一直向上追溯，如果有那么多个层级的父类的话
		
	}
}

注意：由于this和super都要求放在首行，所以要求这两个关键字只能有一个存在
在这里插入图片描述

九、JavaBean

* JavaBean是一种Java语言写成的可重用组件。
	- 所谓 JavaBean，是指符合如下标准的Java类：
	   - 类是公共的
	   - 一个无参的公共的构造器
	   - 有属性，属性一般是私有的，且有对应的get、set方法
	   - 用户可以使用JavaBean将功能、处理、值、函数库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP界面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

Java Bean
1. 所有的成员变量都要使用private关键字修饰 
2. 为每一个成员变量编写一对Getter/Setter方法 
3. 编写一个无参的构造方法 
4. 编写一个全参的构造方法

例如，要写一个PersonBean：

/**
 *下列代码为一个完整的JavaBean 
 * 里面含有：
 * 1、私有的属性 
 * 2、属性对应的get和set方法
 * 
 */

public class Person8 {
	private String name;  //私有的姓名
	private int sex;  //私有的性别，0男1女
	private int age; //私有的年龄
	
	//当编写完属性之后
	//下面的代码用鼠标右键----Source----Generate Getter and Setters...自动的生成
	public void setName(String name){
		this.name = name;
	}
	
	public String getName(){
		return this.name;
	}
	
	public void setSex(int sex){
		this.sex = sex;
	}
	
	public int getSex(){
		return this.sex;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	public int getAge(int age){
		return age;
	}
}

public class Test {
	public static void main(String[] args){
		//JavaBean的使用
		Person8 p8 = new Person8();
		
		p8.setName("张三");
		p8.setSex(0);
		p8.setAge(20);
	}		
}