java 从零开始，学习笔记之基础入门<重载_覆盖_继承>（十）

重载_覆盖_继承

方法的覆盖(重写)

子类继承父类的时候，父类里面的方法都被子类所继承（除了私有的方法），如果父类里面的方法不能够满足子类的需求，那么就必须在子类里面对父类的方法进行覆盖，覆盖的同时要满足一下几个条件:

* 子类覆盖父类的方法时，方法的返回值类型和方法名 方法的参数必须要和父类的保持一致

* 子类中覆盖父类的方法，方法的修饰符类型不能够比父类的方法的修饰符类型更严格

Eg ：父类中的方法修饰符为protected 的，那么你子类的覆盖该方法的访问修饰符要么是protected 要么是public

* 方法的覆盖 在方法的之前有一个 @Override标识

Eg：父类：

package com.ibm.overrideMethod1;

publicclass Person {

//这是父类

public String read(String book){

return"读的书是"+book;

}

public StringeatEgg(String name,int num){

return name+"吃了"+num+"鸡蛋";

}

}

子类：

package com.ibm.overrideMethod1;

publicclass XiaoBai extends 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 String pass;

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 SonSuper extends 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 FatherSuper extends GrandFatherSuper{

privateintid;

public String name;

protectedfloatf;

publicvoid find(){

System.out.println(name);

}

public String fingName(){

returnname;

}

public FatherSuper(){

}

public FatherSuper(String _name){

System.out.println("父类构造的值："+_name);

}

}

输出结果：

父类构造的值：cw

admin

将当前对象作为参数传递给其它方法或构造器

package com.ibm.thises;

publicclass Teacher {

publicvoid show(Teacher t){

System.out.println(t);

}

publicvoid show1(){

show(this);//This是一个当前类的对象，已经调用默认的无参构造器创建好的

Student st = new Student(this);//将当前类的对象作为参数传递到构造器中

}

publicstaticvoid main(String[] args) {

new Teacher().show1();

// System.out.println(new Teacher());

}

}

package com.ibm.thises;

publicclass Student {

private Teacher t;

public Student(Teacher t){

this.t = t;

}

}

自由块：也称游离块

* 不管使用哪个构造器创建对象，游离块首先被执行，然后在调构造器实例化对象

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则判断的是二个对象里面的内容是否相等