第七章总结

1.类的封装

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类。

public class Restaurant1 {//创建一个类

	public static void main(String[] args) {//主方法
		String cookName="Tom Cruise";//厨师的名字叫Tom Cruise
		System.out.println("**请让厨师为我做一份香辣肉丝。***");//输出
		System.out.println(cookName+"切葱花");//输出
		System.out.println(cookName+"洗蔬菜");//输出
		System.out.println(cookName+"开始烹饪"+"香辣肉丝");//输出
		System.out.println("**请问厨师叫什么名字？***");//输出
		System.out.println(cookName);//输出
		System.out.println("请让厨师给我切一点葱花。***");//输出
		System.out.println(cookName+"切葱花");//输出
	}

}

运行结果：

public class Restaurant2 {//创建一个类

	public static void main(String[] args) {//主方法
		Cook1 cook=new Cook1();//创建厨师类的对象
		System.out.println("**请让厨师为我做一份香辣肉丝。***");//输出
		cook.cooking("香辣肉丝");//厨师烹饪香辣肉丝
		System.out.println("**你们的厨师叫什么名字？***");//输出
		System.out.println(cook.name);//厨师回答自己的名字
		System.out.println("**请让厨师给我切一点葱花。***");//输出
		cook.cutOnion();//厨师去切葱花

	}

}
class Cook1{//创建类
	String name;//厨师的名字
	public Cook1(){//定义一个方法
		this.name="Tom Cruise";//厨师的名字叫Tom Cruise
	}
	void cutOnion(){//厨师切葱花
		System.out.println(name+"切葱花");//输出信息
	}
	void washVegetables(){//厨师洗蔬菜
		System.out.println(name+"洗蔬菜");//输出信息
	}
	void cooking(String dish){//厨师烹饪顾客点的菜
		washVegetables();//调用洗蔬菜方法
		cutOnion();//调用切葱花方法
		System.out.println(name+"开始烹饪"+dish);//输出信息
	}
}

 运行结果：

public class Restaurant3 {//创建一个类
public static void main(String[] args) {//主方法
		Cook2 cook=new Cook2();//创建厨师类的对象
		System.out.println("**请让厨师为我做一份香辣肉丝。***");//输出
		cook.cooking("香辣肉丝");//厨师烹饪香辣肉丝
		System.out.println("**你们的厨师叫什么名字？***");//输出
		System.out.println(cook.name);//厨师回答自己的名字
		System.out.println("**请让厨师给我切一点葱花。***");//输出
		cook.cutOnion();//厨师去切葱花
		}
}
class Cook2{//创建类
	private String name;//厨师的名字
	public Cook2(){//定义方法
		this.name="Tom Cruise";//厨师的名字叫Tom Cruise
	}
	private void cutOnion(){//厨师切葱花
		System.out.println(name+"切葱花");//输出信息
		}
	private void washVegetables(){//厨师洗蔬菜
		System.out.println(name+"洗蔬菜");//输出信息
	}
	void cooking(String dish){//厨师烹饪顾客点的菜
		
		washVegetables();//调用方法
		cutOnion();//调用方法
		System.out.println(name+"开始烹饪"+dish);//输出信息
		}
}

 运行结果：

public class Restaurant4 {//创建类
private Cook2 cook=new Cook2();//餐厅封装的厨师类
public void takeOlder(String dish){//下单	Restaurant2 a=new Restaurant2();//创建一个对象
	cook.cooking(dish);//通知厨师做菜
	System.out.println("您的菜好了，请慢用。");//输出信息
}
public String saySorry(){//拒绝顾客请求
	return"抱歉，餐厅不提供此项服务。";//返回字符串
	
}
	public static void main(String[] args) {//主方法
		Restaurant4 water=new Restaurant4();//创建餐厅对象，为顾客提供服务
		System.out.println("**请让厨师为我做一份香辣肉丝。***");//输出
		water.takeOlder("香辣肉丝");//服务员给顾客下单
		System.out.println("**你们的厨师叫什么名字？***");//输出信息
		System.out.println(water.saySorry());//服务员给顾客善意的答复
		System.out.println("**请让厨师给我切一点葱花。***");//输出信息
		System.out.println(water.saySorry());//服务员给顾客善意的答复
	}

}

 运行结果：

2.类的继承：

 继承在面向对象开发思想中是一个非常重要的概念，它使整个程序具有一定的d性，在程序中复用已经定义完善的类不仅可以减少软件开发周期，还可以提高软件的可维护性和可扩展性。

继承其基本思想是基于某父类的扩展，制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法，或者直接重写父类中的某些方法。

1.extends关键字

在java中，让一个类继承另一个类，用extends关键字

child extends parents//子类继承父类

注意：java中的类只支持单继承，即一个子类只能继承一个父类，类似下面的代码是错误的：

child extends parents1,parent2{
//错误的继承语法
}

class Computer{//父类
	String screen="液晶显示屏";
	void startup(){//开机方法
		System.out.println("电脑正在开机，请等待...");//输出
	}
}

public class Pad extends Computer{//创建一个类并继承父类
String battery="5000毫安电池";//子类独有的属性
	public static void main(String[] args) {//主方法
		Computer pc=new Computer();//电脑类
		System.out.println("computer的屏幕是:"+pc.screen);//输出
		pc.startup();//调用父类方法
		Pad ipad=new Pad();//平板电脑类
		System.out.println("pad的屏幕是："+ipad.screen);//子类可以直接使用父类属性
		System.out.println("pad的屏幕是："+ipad.battery);//子类独有的属性
		ipad.startup();//子类可以直接使用父类方法

	}

}

运行结果：

从这个结果可以看出，Pad类继承了Computer类之后，虽然没有定义任何成员方法，但仍然可以调用父类的方法，这个方法就是从父类那里继承过来的。 

3.方法的重写

继承并不只是扩展父类的功能，还可以重写父类的成员方法。重写（还可以称为覆盖）就是在子类中将父类的成员方法的名称保留。重新编写成员方法的实现内容，更改成员方法的存储权限，或是修改成员方法的返回值类型 （重写父类成员方法的返回值是基于J2SE 5.0版本以上的编译器提供的新功能）。

在继承中还有一种特殊的重写方式，子类与父类的成员方法返回值、方法名称、参数类型及个数完全相同，唯一不同的是方法实现内容，这种特殊重写方式被称为重构。

注意：当重写父类的方法时，修改方法的修饰权限只能从小的范围到大的范围改变，例如，父类中的doSomething()方法的修饰权限为protected,继承后子类中的方法doSomething()的修饰权限只能修改为public,不能修改为private。

class Computer2{//父类：电脑
	void showPicture(){//定义一个方法
		System.out.println("鼠标单击");//输出信息
	}
}
public class Pad2 extends Computer2 {//创建一个类并继承父类
void showPicture(){//重写父类的方法
	System.out.println("手指点击触摸屏");//输出信息
}
	public static void main(String[] args) {//主方法
		Computer2 pc=new Computer2();//电脑类
		System.out.print("pc打开图片：");//输出信息
		pc.showPicture();//调用方法
		Pad2 ipad=new Pad2();//平板电脑类
		System.out.print("ipad打开图片：");//输出信息
		ipad.showPicture();//重写父类方法
		Computer2 computerpad=new Pad2();//父类声明，子类实现
		System.out.print("computerpad打开图片：");//输出信息
		computerpad.showPicture();//调用父类方法，实现子类重写的逻辑
	}

}

运行结果：

注意：在java语言中，一个类只可以有一个父类！

super关键字

super关键字可以调用父类的方法和属性，它的使用方法和this关键字相似。但this关键字代表本类的对象，super关键字带调用的是父类的方法

super.property;//调用父类的属性
super.method();//调用父类的方法

class Computer3{//父类：电脑
	String sayHello(){//定义一个方法
		return"欢迎使用";//返回一个字符串
	
	}
	
}
public class Pad3 extends Computer3 {//子类：平板电脑
	String sayHello(){//重写方法
		 return super.sayHello()+"平板电脑";//调用父类方法，在其结果后添加字符串
	}

	public static void main(String[] args) {//主方法
Computer3 pc=new Computer3();//电脑类
System.out.println(pc.sayHello());//调用父类的方法并输出
Pad3 ipad=new Pad3();//平板电脑类
System.out.println(ipad.sayHello());//调用子类的方法并输出

	}

}

运行结果：

 注意：如果在子类构造方法中使用类似super()构造方法，其他初始化代码只能写在super()之后，不能写在前面，否则会报错。

 Object类——所有类的父类

在java中，所有的类都直接或间接继承了java.lang.Object类。Object类是所有类的父类，是java类层中的最高层类。

注意：Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

1.getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName ()方法可以取得类的名称。

getClass().getName();//调用getClass()里的getName()方法

可以将getClass()方法与toString()方法联合使用。

2.toString()方法

toString()方法的功能是将一个对象返回为字符串形式，它会返回一个String实例。在实际的应用中通常重写toString()方法。

public class ObjectInstance {创建类
public String toString(){//重写toString()方法
	return "在"+getClass().getName()+"类中重写toString()方法";//返回值
}
	public static void main(String[] args) {//主方法
		System.out.println(new ObjectInstance());//调用方法并输出，打印本类对象
	}

}

运行结果：

 3.equals()方法

比较两个对象的实际内容。

class V{//自定义类V
	
}
public class OverWriteEquals {//创建一个方法

	public static void main(String[] args) {//主方法
		String s1="123";//实例化两个对象，内容相同
		String s2="123";//实例化对象
		System.out.println(s1.equals(s2));//使用equals()方法
		V v1=new V();//实例化两个V类对象
		V v2=new V();//实例化对象
		System.out.println(v1.equals(v2));//使用equals()方法
	}

}

运行结果：

类的多态

类的多态性指“一种定义，多种实现”，类的多态性可以从两方面 体现：方法的重载，类的上下转型。

方法的重载：重载（不需要继承）：返回参数不同、传入参数不同、  方法名相同

      

public class OverLoadTest {//定义一个方法
	public static int add(int a){//定义一个方法并传入一个int型参数
		return a;//返回一个整型值
	}
	public static int add(int a,int b){//定义一个方法并传入两个参数
		return a+b;//返回a+b的值
	}
	public static double add(double a,double b){//定义一个方法并传入两个参数
		return a+b;//返回a+b的值
	}
	public static int add(int a,double b){//定义一个方法并传入两个参数
		return (int)(a+b);//返回a+b的值，同时利用强制转换成int型
	}
	public static int add(double a,int b){//定义一个方法并传入两个参数
		return (int)(a+b);//返回a+b的值，同时利用强制转换成int型
	}
	public static int add(int...a){//定义一个不定长参数方法
		int s=0;//定义一个int型变量并赋予初值
		for(int i=0;i

    运行结果：

 注意：虽然在方法的重载中可以使两个方法的返回类型不同，但只有返回类型不同不足以区分两个方法的重载，还需要通过参数的个数以及参数的类型来设置。

向上转型：子类转变成父类类型

class Quadrangle{//四边形类
public static void draw(Quadrangle q){//四边形类中的方法
//SomeSentence
}
}
public class Parallelogram extends Quadrangle{//平行四边形类，继承了四边形类
public static void main(String args[]){//主方法
Parallelogram p=new Parallelogram();//实例化平行四边形类对象引用
draw(p);//调用父类方法
}
}

运行无结果

向下转型：父类转变成子类 使用强制转换

class Quadrangle{//父类
	public static void draw(Quadrangle q){//父类方法
		//SomeSentence
	}
}
public class Parallelogram extends Quadrangle {//子类继承父类

	public static void main(String[] args) {//主方法
	draw(new Parallelogram());//调用方法并传入子类对象
	Quadrangle q=new Parallelogram();//将平行四边形对象看作是四边形对象，称为向上转型 *** 作
	Parallelogram p=q;//向下转型

	}

}

运行结果：

instanceof关键字

当在程序中执行向下转型 *** 作时，如果父类对象不是子类对象的实例，就会发生classcastException异常，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例。

myobject instanceof ExampleClass//判断是否为该类的实例对象

 myobject:某类的对象引用。

ExampleClass:某个类

使用instanceof *** 作符的表达式返回值为布尔值。

class Quadrangle{//类名
	public static void draw(Quadrangle q){//构造一个方法并传入一个参数
		//SomeSentence
	}
}
class Square extends Quadrangle{//构造一个类并继承另一个类
	//SomeSentence
}
class Anything{//构造一个类
	//SomeSentence
}
public class Parallelogram extends Quadrangle {//创建一个类并继承另一个类

	public static void main(String[] args) {//主方法
		Quadrangle q=new Quadrangle();//创建一个对象
		if(q instanceof Parallelogram){//判断该对象是否属于该类
			Parallelogram p=(Parallelogram)q;//进行强制转换
		}
		if(q instanceof  Square){//判断该对象是否属于该类
			Square s=(Square) q;//进行强制转换
		}
		System.out.println(q instanceof  Anything );//输出信息
	}

}

运行结果：

import 包名1[.包名2[.包名3...]].类名;