Java中的继承体现的是类和类之间的关系。继承的好处在于,实现了代码的重复利用。
1.关于Java继承的几个概念
1.B继承了A,则B是A的子类,A是B的父类(超类,基类)。
2.Java中只能是单继承,即一个子类只能有一个父类,不能有多个。但可以多重继承,即可以C继承B,B继承A。
2.Java继承的语法格式
//B继承了A
class B extends A {
}
代码示例:
class Father {
String name;
int age;
//行为
public void eat () {
System.out.println("吃大盘鸡拌面");
}
}
//使用了extends以后 Son 类就继承了Father这个类
//就意味着Son类可以使用Father类下面的某些属性和某些方法
class Son extends Father{
}
public class Demo1 {
public static void main(String[] args) {
//创建一个Son类对象
Son son = new Son();
//继承之后,子类可以使用父类一些属性
son.name = "奇奇";
son.age = 1;
System.out.println(son.name); //奇奇
System.out.println(son.age); //1
son.eat(); //吃大盘鸡拌面
}
}
注意事项:
1.成员变量(属性)
对于父类中公开的(public)和默认的(不加权限修饰符)成员变量,子类可以直接继承使用。
对于父类中私有的(private)的成员变量,子类不可使用。
2.成员方法
对于父类中公开的和默认的成员方法,子类可以直接拿来用。
对于父类中私有的的成员方法,子类不可以使用。
3.构造方法
构造器谈不上继承,每个类中所需要的构造方法都需要重新写。(因为每个类的类名都不同,而构造器的名字是与类名一致的)
先执行父类的构造方法,再执行子类中的构造方法。
父类中如果只有有参构造,子类中的无参构造方法的定义和使用都会报错。解决方法是在父类中写一个对应的无参构造方法。
代码示例:
class Father {
//只要是公开的或者默认的属性,子类可以使用的
public String name; //公开的一个属性
int age; //默认的一个属性
private int id; //private修饰的私有属性,子类不能使用
//无参构造方法
public Father () {
System.out.println("父类的构造方法");
}
//有参构造方法
public Father (String name) {
this.name = name;
}
//使用public修饰的eat方法,子类可以直接调用
public void eat () {
System.out.println("吃窝窝头");
}
//默认的方法,子类可以直接调用
void work () {
System.out.println("开拖拉机耕地");
}
// 使用private修饰的私有的方法,子类不能直接调用
private void smoking () {
System.out.println("抽旱烟");
}
}
class Son extends Father {
}
public class Demo1 {
public static void main(String[] args) {
Son son = new Son();
//验证name age在子类中可以使用的
son.name = "狗蛋";
son.age = 12;
//son.id = 12; //报错
son.eat();//可以使用父类的公开的方法
son.work();
//不可以使用父类私有化的方法
//son.smoking(); //报错
}
}
3.私有化的属性和方法在继承时如何操作
在父类中写一个公开的方法来调用私有的属性和方法,然后在子类中直接继承使用这个公开的方法。
代码示例:
class Father1 {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//私有的方法
private void smoking () {
System.out.println("抽旱烟");
}
//在公开的方法中调用私有的方法即可
public void test () {
smoking();
}
}
class Son1 extends Father1 {
}
public class Demo2 {
public static void main(String[] args) {
Son1 son1 = new Son1();
//使用setter和getter方法赋值取值
son1.setName("狗蛋");
System.out.println(son1.getName());
son1.test(); //可以调用smoking方法
}
}
4.重写【override】
目的:子类可以继承父类非私有化的成员方法,但有时父类的方法不能满足子类的需求,此时可以进行重写。在不改变父类方法的需求的基础之上,可以在子类中重写父类的方法。其特点是,除了方法体不一样,其他一模一样。
注意事项:
1.@Override 是重写的严格限定,示意这个方法是重写的父类的方法,不是子类中独有的方法。
2.子类重写的方法不影响父类的方法调用效果。
重写的要求:
1.必须要有继承关系。
2.父类中私有化的方法不能被重写。
3.在子类中重写的方法除了方法体不一样,其他都必须与父类方法中的一致。
4.必须在子类中去重写父类。
代码示例:
class Father {
public void eat () {
System.out.println("吃粗粮");
}
public void driver () {
System.out.println("开拖拉机");
}
}
class Son extends Father {
//当父类不能满足子类的需求,可以在子类中重写父类的方法
@Override
public void eat() {
System.out.println("吃白面馒头");
}
@Override
public void driver() {
System.out.println("开小汽车");
}
}
public class Demo1 {
public static void main(String[] args) {
Son son = new Son();
son.eat(); //吃白面馒头
son.driver(); //开小汽车
//子类重写父类中的方法,不影响父类方法的使用
Father father = new Father();
father.eat(); //吃粗粮
father.driver(); //开拖拉机
}
}
5.重载【overload】
在Java中,同一个类中有很多方法,方法的名字是一样的,但是参数不同,这种方式就叫做方法的重载。
注意事项:
1.方法的重载必须写在同一个类中。
2.重载方法的名字一定是一样的,参数一定是不一样的。
代码示例:
public class Person {
//在一个类中,方法法名字一样,但是参数一定不一样。这叫方法的重载
public void test () {
System.out.println("test");
}
public void test (String name) {
System.out.println(name);
}
public void test (int i) {
System.out.println(i);
}
//修饰符可以不一样
void test (double d1) {
}
//返回值可以不一样
public String test(String str1, String str2) {
return str1 + str2;
}
}