使用java实现面向对象编程

使用java实现面向对象编程

为什么使用面向对象

现实世界就是‘面向对象的’。任何存在事物都可以看做‘对象’，面向对象就是采用现实模拟的方法设计和开发程序，面向对象技术利用"面向对象的思想"去描述"面向对象的世界"，实现了虚拟世界和现实世界的一致性，符合人们的思维习惯，使客户和软件设计开发人员之间，软件设计开发人员内部见柳更加顺畅，同时有代码重用性高，可靠性高等优点，大大提高了软件尤其是大型软件的设计和开发效率。

构造方法

public class Dog {
	/**
	 * 宠物狗狗类
	 * @param args
	 */
	String name="无名氏";
	int health=100;
	int love=0;
	String strain="聪明的拉布拉多";//品种
	//无参构造方法
	public  Dog(){
	         name="布布"；
	         health="100";
	         love="20";
	         string strain="拉布拉多"；
	}
	public void print() {
		/**
		 * 输出狗信息
		 */
			System.out.println("宠物的自白:\n我的名字叫"+this.name+",健康值是"+this.health
					+",亲密值："+this.love+",品种是"+this.strain+".");
		}
		//测试无参构造方法
		public static void main(String[] args){
				Dog dog=new Dog();
				dog.print();
		}
	}

构造方法是一个特殊的方法。当没有Penguin()方法是，系统会提供一个空的Penguin()方法。
构造方法的名称和类名相同，没有返回值类型，构造方法的主要作用就是在创建对象时执行一些初始化操作，如给成员属性赋初始值。

运行结果为：

宠物的自白:
我的名字叫布布,健康值是100,亲密值：20,品种是聪明的拉布拉多.

**

调用属性和方法的语法

1.通过构造方法来创建对象：如"Penguin p=new Penguin();"。
2.通过对象名.属性名的方法调用属性，如"p.name=“qq”;"。
3.通过对象名.方法名的方法调用方法，如"p.print();"。**

重载

定义：有三个构造方法，方法名相同，参数列表不同，这称为构造方法的重载。

public class Penguin{
	String name="无名氏"；
	int health =100;
	int love=0;
	String sex="Q仔";
	/**
	*无参构造方法
	*/
	public Penguin(){
		name="楠楠";
		love=20;
		sex="Q妹";
		System.out.println("执行构造方法");
	}
	/**
	*两个参数的构造方法
	*/
	public Penguin(String name,String sex){
	this.name=name;
	this.sex=sex;
	}
	/**
	*四个参数的构造方法
	*/
	public Penguin(String name,int health,int love,String sex){
	this.name=name;
	this.health=health;
	this.love=love;
	this.sex=sex;
	}
	/**
	*输出企鹅的信息
	*/
	public void print(){
		System.out.println("宠物的自白:\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+",性别是"+this.sex+"。");
	}
	/**
	*测试构造方法的使用
	*/
	public static void main(String[] args){
		Penguin pgn=null;
		pgn=new Penguin();
		pgn.print();
		pgn=new Penguin("亚亚"，"企鹅")；
		pgn.print();
		pgn=new Penguin("美美",80,20,"Q仔");
		pgn.print();
	}
}

在没有给类提供任何构造方法时，系统会提供一个无参的方法体为空的默认构造方法，一旦提供了自定义构造方法，系统将不再提供这个默认构造方法，如果要使用它，则程序员必须手动添加。
如果一个类包含两个或者两个以上的方法，它们的方法名相同，方法的参数的个数或参数类型不同，则称该方法被重载了，这个过程称为方法重载，成员方法和构造方法都可以进行重载。
————————————————

方法重载的判断依据

1.必须在同一个类里
2.方法名相同
3.参数列表(方法参数的个数或参数类型)不同
4.与方法返回值和方法修饰符没有任何关系
（在使用this调用自身的其他构造方法时，只能作为第一条语句）

Static修饰符

static可以用来修饰属性，方法和代码块，static修饰的变量属于这个类所有，即由这个类创建的所有对象共用同一个static变量，通常把static修饰的属性和方法称为类属性（类变量）和类方法，不使用static修饰的属性和方法属于单个对象，通常称为实例属性（实例变量）和实例方法。
静态成员由类名直接调用，也可以由对象调用，静态变量是类级别的，只开辟一个空间。
当类被首次调用时，静态成员即初始化
静态方法只能调用静态属性

public class StaticTest {
	static int i;
	static int m=30;
	int j;
	int k=25;
	static{ //静态块
		i=10;
		System.out.println("i的初始化值为:"+i);
	}
	public StaticTest(){  //无参构造方法
		j=20;
		System.out.println("j的初始化值为:"+j);
	}
	public static void getNum(){  //静态方法
		System.out.println("得到i的值为"+i);
	}
	public static void main(String[] args) {
		StaticTest st=new StaticTest();
		System.out.println("i的值为:"+StaticTest.i);
		st.getNum();
		System.out.println("m的值为："+st.m);
		System.out.println("k的值为："+st.k);
	}

由结果我们得出以下结论：
1.在加载类的过程中，完成静态变量的内存分配，再执行静态块，两者是在创建对象之前执行的。
2.类属性的类方法可以通过类名和对象名访问，实例属性和实例方法只能通过对象名访问。
3.类方法只能访问类属性和其他类方法

注意
静态方法中不能使用this和super关键字

封装

封装是面向对象的三大特征之一，就是将类的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的具体步骤
1.修改属性的可见性来限制对属性的访问
2.为每个属性创建一对赋值方法和取值方法，用于对这些属性的存取
3.在赋值方法中，加入对属性的存取控制语句

封装的好处
1.隐藏类的实现细节
2.让使用者只能通过程序规定的方法来访问数据
3.可以方便的加入存取控制语句，限制不合理操作

封装时会用到多个权限控制符来修饰成员变量和方法，区别如下：
private：成员变量和方法，只能在其定义的类中被访问，具有类可见性
默认：成员变量和方法，只能在其定义的包里被访问，具有包可见性
protected：可以被同一个包里的类访问，被同一个项目中不同包中的子类访问
public：可以被同一个项目中的所有类访问，具有项目可见性，这是最大的访问权限

/**
 * 宠物狗狗类，使用权限修饰符private和public进行封装
 */
class Dog {
	private String name="无名氏";
	private int health=100;
	private int love=0;
	private String strain="聪明的拉布拉多犬";
	/**
	 * 通过构造方法指定狗狗的昵称，品种
	 */
	public Dog(String name,String strain){
		this.name=name;
		this.strain=strain;
	}
	/**
	 * 通过吃饭增加健康值
	 */
	public void eat(){
		if(health>=100){
			System.out.println("狗狗需要多运动啊！");
		}else{
			health=health+3;
			System.out.println("狗狗吃饱饭了！");
		}
	}
	/**
	 * 通过玩游戏增加与主人的亲密度，减少健康值
	 */
	public void play(){
		if(health<60){
			System.out.println("狗狗生病了！");
		}else{
			System.out.println("狗狗正在和主人玩耍。");
			health=health-10;
			love=love+5;
		}
	}
	/**
	 * 读取狗狗的昵称
	 */
	public String getName(){
		return name;
	}
	/**
	 * 读取狗狗的健康值
	 */
	public int getHealth(){
		return health;
	}
	/**
	 * 读取狗狗与主人的亲密度
	 */
	public int getLove(){
		return love;
	}
	/**
	 * 读取狗狗的品种
	 */
	public String getStrain(){
		return strain;
	}
	/**
	 * 输出狗狗的信息
	 */
	public void print(){
		System.out.println("宠物的自白:\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+",我是只"+this.strain+"。");
	}
	public static void main(String[] args) {
		Dog dog=new Dog("欧欧","酷酷的雪纳瑞");
		dog.play();
		System.out.println("健康值是"+dog.getHealth());
		dog.eat();
		dog.print();
	}

}

运行结果：

this

1.使用this调用重在的构造方法，只能在构造方法中使用，必须是构造方法的第一条语句
2.因为this在对象内部指代自身的引用，所以this只能调用实例变量，实例方法和构造方法
3.this不能调用类变量和类方法，也不能调用局部变量