重载_覆盖_继承
方法的覆盖(重写)
子类继承父类的时候，父类里面的方法都被子类所继承（除了私有的方法），如果父类里面的方法不能够满足子类的需求，那么就必须在子类里面对父类的方法进行覆盖，覆盖的同时要满足一下几个条件:
* 子类覆盖父类的方法时，方法的返回值类型和方法名 方法的参数必须要和父类的保持一致
* 子类中覆盖父类的方法，方法的修饰符类型不能够比父类的方法的修饰符类型更严格
Eg ：父类中的方法修饰符为protected 的，那么你子类的覆盖该方法的访问修饰符要么是protected 要么是public
* 方法的覆盖 在方法的之前有一个 @Override标识
Eg：父类：
package com.ibm.overrideMethod1;
publicclass Person {
//这是父类
public String read(Stringbook){
return"读的书是"+book;
}
public StringeatEgg(String name,int num){
return name+"吃了"+num+"鸡蛋";
}
}
子类：
package com.ibm.overrideMethod1;
publicclass XiaoBaiextends Person {
@Override
public String read(String book) {
return"小白正在"+super.read(book);
}
//在小白这类里面 也可以调用read方法
//父类中的方法就不能满足子类的需求
//对父类里面的方法进行覆盖
publicstaticvoid main(String[] args) {
XiaoBai xb=new XiaoBai();
String ss=xb.read("一千零一夜");
System.out.println(ss);
}
}
结果：小白正在读的书是一千零一夜
总结：子类覆盖了父类中的方法，子类的方法和父类的方法保持一致，只是方法所要做的操作改变，也就是对方法进行改写。
方法的重载（overload）
在一个类中，所有的方法的方法名相同，只是方法的参数列表，返回值类型不同
返回值类型不同，那么你所传的参数的个数也必须不同
返回值类型相同,
1 参数列表的个数不同
public void run(){//汽车run方法
}
//返回值类型要相同
public void run(String name){}
public void run(Stringname,String pass){
}
2 所传参数的类型不同 个数相同
public void run(String name){}
public void run(int i){
}
Eg：publicclass Student {
//打印出学生的信息
publicvoid show(){
System.out.println("这是学生类");
}
public void show(String name){
System.out.println("学生姓名"+name);
}
public void show(String name ,int age){
System.out.println("学生的姓名"+name+"学生年龄"+age);
}
public void show (String name,int age,boolean flag){
if(flag==true){
System.out.println("学生姓名"+name+"年龄"+age+"考试通过");
}else{
System.out.println("学生姓名"+name+"年龄"+age+"考试不通过");
}
}
构造器的重载
构造器的语法：
语法：访问修饰符 +类名(参数列表){}
一个类中默认的都有一个无参数的构造器
构造器也有含参数的构造器 （参数可以是一个 二个 或者多个）
如果一个类中含有含参数的构造器，那么含参数的构造器是不是会将默认的无参的构造器覆盖，我们调用的就是含参数的构造器
定义参数为不同类型的构造器
在一个类中，我通过构造器对不同类型的值进行初始化？
Eg：
publicclass NewManyObject {
doubled;
longl; //定义四个不同类型的属性
inti;
String s;
//这个是默认的无参的构造器 1
public NewManyObject(){
}
//不同类型的属性进行初始化 2
public NewManyObject(double d){
this.d=d;
System.out.println(this.d);
}
//3
public NewManyObject(long l){
this.l=l;
}
//4
public NewManyObject(int i){
this.i=i;
}
//5
public NewManyObject(String s){
this.s=s;
}
publicstaticvoid main(String[] args) {
//给double型属性初始化 2号构造器
NewManyObject mo=newNewManyObject(12.5d);
}
}
总结：
构造器的重载，只是在构造器中所传的参数的类型和参数的个数不同，构造器名一样都是类名保持一致。你创建对象的时候呢，要对什么属性进行初始化，就调用对应的构造器
构造器调用构造器： 通过this关键字来调用对应的构造器
publicclass NewManyObject01 {
private String name;
private Stringpass;
private String age;
private String tel;
// 传一个参数的构造器，对name属性进行初始化 1
public NewManyObject01(String name){
this.name=name;
}
//2
public NewManyObject01(String name,String pass){
// this.name=name;
//在这个构造器中调用1号
this(name);//表示调用传递一个参数的构造器
this.pass=pass;
}
//3
public NewManyObject01(String name,Stringpass,String age){
this(name,pass);//表示调用2号构造器
this.age=age;
}
}
Super和this关键字
Super关键字
子类继承父类的时候：
在子类中中通过super关键字打点调用父类里面的属性和方法
Super关键字还可以调父类的构造器
子类：
|
package com.ibm.supers;
publicclass SonSuperextends FatherSuper{
publicvoid show(){ //通过super关键字可以访问到父类中的属性 //但是如果父类中的属性用private修饰，则super访问不到 super.f = 12.5f; super.name ="admin"; //一个类继承了一个父类可以直接访问父类中的方法 super.find(); super.select(); } //如果父类中有和子类相同名的方法，那么我想访问父类中的方法 publicvoid find(){ System.out.println("我是子类的方法"); }
public SonSuper(){ //在子类的构造器中访问父类的构造器 //子类中只能调到父类的构造器，不能调到父类的父类的构造器，但是可以调到父类的父类的属性 super("cw"); } publicstaticvoid main(String[] args) { new SonSuper().show(); }
} |
父类：
|
package com.ibm.supers;
publicclass FatherSuperextends GrandFatherSuper{ privateintid; public Stringname; protectedfloatf;
publicvoid find(){ System.out.println(name); }
public String fingName(){ returnname; } publicFatherSuper(){
}
public FatherSuper(String _name){ System.out.println("父类构造的值："+_name); }
}
|
输出结果：
|
父类构造的值：cw admin |
将当前对象作为参数传递给其它方法或构造器
|
*块：也称游离块
* 不管使用哪个构造器创建对象，游离块首先被执行，然后在调构造器实例化对象
|
package com.ibm.news;
publicclass Test { privateintid;
public Test(int id) { System.out.println("------我是构造器----"); this.id = id; }
{ System.out.println("-------我是一个非静态的初始化块------"); this.id = 15; //调方法 show(); }
publicvoid show(){ System.out.println(this.id); }
publicstaticvoid main(String[] args) { Test tt = new Test(20); System.out.println(tt.id); }
}
|
输出结果：
|
-------我是一个非静态的初始化块------ 15 ------我是构造器---- 20 |
= = 和equals
= =是判断判断二个引用对象 或者简单数据类型所指向的值是否相等
Equals则判断的是二个对象里面的内容是否相等