了解Java程序之面向对象

面向对象之多态

继承中成员方法的访问:
子类继承父类,如果子类的成员方法和父类的成员方法不一致的情况:分别调用即可;
如果子类的成员方法名和父类的成员方法名一致的情况:
1)先在子类中找,如果存在在方法名,就使用;
2)如果自中不存在,就在父类中找,存在就使用;
3)父类中也没有那就编译报错;

//父类
class Fu{
	public void show(){
		System.out.println("show Fu...") ;
	}
	public void show(){
		System.out.println("show Fu...") ;
	}
}
//子类
class Zi extends Fu{
	public void method(){
		System.out.println("method Zi...") ;
	}
	/*
	 void show(){		//正在尝试分配更低的访问权限; 以前为public
		System.out.println("show Zi...") ;
	}
	*/
	public void show(){		
		System.out.println("show Zi...") ;
	}
}
//测试类
class ExtendsDemo1{
	public static void main(String[] args){
		//创建子类对象
		Zi zi = new Zi() ;//new的是子类,现在子类成员位置找,如果存在,就调用
		zi.show();
		zi.method() ;
	}
}

方法重写:
概念:
子类和父类出现一模一样的方法声明;
重写的注意事项:
子类重写父类的方法时,访问权限不能更低,最好在前面加上权限修饰符public;
要么就是子类重写父类的方法时,访问权限比父类大(或者和父类相同);
子类继承父类的时候,子类中的主体功能可能使用父类的功能,并且还能够使用自己的 特有功能,需要将父类的功能重写!
overload和override的区别?
方法重载和方法重写
方法重载:定义方法的时候,如果方法名一样,参数列表不同,与返回值无关;
参数列表不同:1)参数个数不同2)参数类型不同;
构造方法可以方法重载;
方法重写(重点):继承关系中,子类出现了和父类一模一样的方法声明,将父类覆盖(复写),创建子类对象,调用该方法,执行子类的功能!
this和super的区别?
this:当前当前类对象的地址值引用
super:代表父类的空间标识(父类对象的地址值引用)
调用成员变量
this.成员变量: 访问本类成员位置的变量
super.成员变量: 访问父类的成员位置变量
调用成员方法
this.成员方法名();
supser.成员方法名() ;
调用构造方法
this():访问本类无参构造方法
this(…): 访问本类有参构造
super():访问父类的无参构造
super(…):访问父类的有参构造

//定义一个手机类
class  Phone{
	//定义一个打电话的功能
	public void call(String name){
		System.out.println("给"+name+"可以打电话了...") ;
	}
}
//新的手机类
class NewPhone extends Phone{
	//定义call方法和父类的功能一模一样
	public void call(String name){
		//System.out.println("给"+name+"可以打电话了...") ;
		super.call(name) ;
		System.out.println("可以发短信...");
	}
}
//测试类
class ExtendsDemo2{
	public static void main(String[] args){
		//创建子类对象
		NewPhone np = new NewPhone();
		np.call("小白");
	}
}

final关键字
final:状态修饰符 ,终态,最终的,无法更改的
可以修饰类,该类不能被继承
可以修饰成员变量:此时变量是一个常量!(自定义常量)
可以修饰成员方法:该方法不能被重写
final修饰变量:注意事项:
该变量如果是一个基本数据类型,该基本数据类型的值(已经初始化)不能再变化!
如果final修饰的变量是一个引用数据类型,引用数据类型中的空间地址值不能再变化,但是可以访问里面的成员变量
final修饰变量初始化时机:
1)定义了,但是没有初始化,一定是在执行完构造方法之前需要对final修饰的变量进行初始化
2)本身在成员变量位置定义的final修饰的变量(非静态的变量),已经初始化了,后面构造代码块或者构造方法中 都不能再对其赋值了

多态:

概念:
一个事物在不同时刻的不同状态;
多态的好处
1)提高代码的维护性(继承来保证)
2)提高代码的扩展性(由多态保证)
多态的弊端:
父类引用指向子类对象(向上转型),无法访问子类的特有功能!
多态的前提条件:
1)继承关系
2)方法重写
3)父类引用指向子类对象 (向上转型)
需要访问子类特有功能
1)直接在测试的时候,子类去创建自己的对象
2)将父类的引用强制转换为子类的引用 :向下转型
转型时的异常:
在多态中,向下转型如果使用不当,那么会出现程序的异常(运行时期异常)

//父类
 class  Person{
	private String name;
	private int age;
	public Person(){}
	public Person(String name,int age){
		this.name=name;
		this.age=age;
		System.out.println("姓名:"+name+", 年龄:"+age);
	}
	public void eat(){
		System.out.println("人都要吃饭!");
	}
}
//南方人
class NorthPerson extends Person{
	public NorthPerson(){}
	public NorthPerson(String name,int age){
		super(name,age);
	}
	public void eat(){
		System.out.println("南方人喜欢吃米饭!");
	}
	public void mercantile(){
		System.out.println("南方人喜欢经商!");
	}
}
//北方人
class SouthPerson extends Person{
	public SouthPerson(){}
	public SouthPerson(String name,int age){
		super(name,age);
	}
	public void eat(){
		System.out.println("北方人喜欢吃面条!");
	}
	public void exam(){
		System.out.println("北方人喜欢考试!");
	}
}
//测试类
class Test3{
	public static void main(String[] args){
		Person p = new NorthPerson("张三",23);
		NorthPerson np = (NorthPerson)p;
		p.eat();
		np.mercantile();
		p=new SouthPerson("李四",22);
		SouthPerson sp = (SouthPerson)p;
		p.eat();
		sp.exam();
	} 
}