本文详细解析了Java中的继承机制，包括概念、作用、关键字，以及extends与implements的区别。接着介绍了抽象类、抽象方法、接口及其特点，以及方法重写的概念、规则和实例。展示了面向对象编程中的关键概念如何提高代码复用和扩展性。
目录
1.继承
1.1 继承的概念
1.2 继承的作用
1.3 继承关键字
1.4 extends与implements的相同点与不同点
1.5 继承的优缺点
1.6继承的实例
2.抽象类
2.1抽象类的概念
2.2抽象类的特征
2.3抽象类与普通类的区别
2.4抽象类实例
3.方法重写
3.1方法重写的概念
3.2方法重写的规则
3.3方法重写的实例
3.4方法重写与方法重载的关系
4.接口
4.1接口的概念
4.2接口的作用
4.3接口的命名
4.4接口和类的区别
4.5接口和抽象类的区别
4.6接口实例
———————————————————————————————————————————
1.继承
1.1 继承的概念
•继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。•继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方 法， 或子类从父类继承方法，使得子类具有父类相同的行为。
1.2 继承的作用
•子类拥有父类的属性和方法，减少重复的代码，维护性高。•代码简洁，提高了代码的复用性。
1.3 继承关键字
•class——定义类•interface——定义接口•extends——继承父类•implements——实现接口
1.4 extends与implements的相同点与不同点
相同点
•都属于Java中的继承•都发生在多各类中
不同点
•extends只能单继承，implements可以实现多继承
•extends继承父类时，父类中可以存在方法的默认实现而implements在实现接口时接口中不能有方法实现
•extends发生在子类和父类之间，implements发生在实现类和接口之间
1.5 继承的优缺点
优点：
提高代码的复用性子类中重复的代码只需要在父类中写一遍，所有子类都可以应用提高代码的可维护性只需要修改父类属性和方法，所有的子类都会应用提高类和类之间的关联性，为多态做基础其实这也是继承的缺点，增加了类和类之间的耦合度，耦合度的增加意味着后期扩展性的降低
缺点：
提高了类之间的耦合性，会造成代码之间的联系越紧密，代码独立性越差
1.6继承的实例
创建一个父类
// 父类
public class Person {
//public 公共的
public int money = 1_0000_0000;
public void say(){
System.out.println("说话");
}
}
创建一个子类
//student is person
//Teacher student也叫派生类或者子类
//子类可以继承父类的所有方法
public class Student extends Person{
}
创建一个测试类
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.money);
}
}
2.抽象类
2.1抽象类的概念
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
2.2抽象类的特性
•抽象类不能被实例化•由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用•在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口
2.3抽象类与普通类的区别
1.抽象类不能被实例化2.但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例3.普通类可以被实例化4.抽象方法无方法体5.普通方法有方法体
2.4抽象类实例
abstract class Employee {//定义抽象类Employee
private String name;//这是三个抽象类的私有成员
private String address;
private int age;
public Employee(String name,String address,int age) {//抽象类的构造方法
this.name=name;
this.address=address;
this.age=age;
}
public String getName() {//抽象类的成员方法
return this.name;
}
public String getAddress() {//抽象类的成员方法
return this.address;
}
public int getAge() {//抽象类的成员方法
return this.age;
}
public abstract double getSalary();//抽象类的抽象方法
}
class Salary extends Employee {//抽象类的非抽象子类，必须继承！！！
private double salary;//子类的私有成员
public Salary(String name,String address,int age,double salary) {//子类的构造方法
super(name,address,age);//super()来获取父类(抽象类Employee)的三个成员属性
setSalary(salary);
}
public void setSalary(double salary) {//子类的成员方法
this.salary=salary;
}
public double getSalary() {//子类的成员方法
return this.salary;
}
}
public class AbstractDemo {
public static void main(String[] args) {
//Employee c=new Employee("王五","C小区3单元301",20);//此行代码编译报错，因为抽象类不能实例化对象
Employee a=new Salary("张三","A小区1单元101",25,3000.00);//通过自身的非抽象子类来实例化对象
Salary b=new Salary("李四","B小区2单元201",30,4500.00);//非抽象子类可以实例化对象
System.out.println("第一个员工的姓名为："+a.getName()+", 住址为："+
a.getAddress()+", 年龄为："+a.getAge()+", 薪水为:"+a.getSalary()+"!");//输出相应成员的属性值
System.out.println("第二个员工的姓名为："+b.getName()+", 住址为："+
b.getAddress()+", 年龄为："+b.getAge()+", 薪水为:"+b.getSalary()+"!");//输出相应成员的属性值
}
}
3.方法重写
3.1方法重写的概念
•重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！•子类能够根据需要实现父类的方法。•重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。
3.2方法重写的规则
- 方法名相同
- 参数列表相同
- 返回值类型相同或者是其子类
- 访问权限不能严于父类
- 父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
- 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
- 父类的私有方法不能被子类覆盖
- 不能抛出比父类方法更多的异常
3.3方法重写的实例
class ElectricAppliance{
public void move(){
System.out.println("电器需要电压");
}
}
class Television extends Animal{
public void move(){
System.out.println("电视需要220伏");
}
}
public class TestTelevision {
public static void main(String args[]){
// ElectricAppliance对象
ElectricAppliance a = new ElectricAppliance();
// Television 对象
ElectricApplianceb = new Television ();
a.move();// 执行 ElectricAppliance类的方法
b.move();//执行 Television 类的方法
}
}
3.4方法重写与方法重载的关系
其实它们根本没有关系
•( 1 )方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载。•( 2 )方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写。•( 3 )方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
4.接口
4.1接口的概念
1.接口，在Java语言中是一个抽象类型，是抽象方法的集合，接口以interface来声明
2.接口并不是类
3.接口无法被实例化，但可以被实现
4.2接口的作用：
提高代码的可扩展性和后期的维护性
4.3接口的命名：
以 I 开头，以包名结尾
4.4接口和类的区别
接口不能用于实例化对象
接口没有构造方法
接口中的所有方法必须是抽象方法
接口当中只能声明静态常量，不能声明成员变量
接口是被实现的，而且是多实现
接口支持多继承
4.5接口和抽象类的区别
抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行；接口没有构造方法
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的
接口中不能含有静态代码块以及静态方法；而抽象类是可以有静态代码块和静态方法
一个类只能继承一个抽象类，而一个类可以实现多个接口
4.6接口实例
定义一个接口
public interface Jumpping {
public abstract void jump();
}
定义抽象动物类
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}
定义具体猫类
public class Cat extends Animal implements Jumpping{
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override//重写eat（）方法
public void eat() {
System.out.println("猫吃鱼");
}
@Override//重写jump（）方法
public void jump() {
System.out.println("kt猫可以跳绳了");
}
}
定义具体狗类
public class Dog extends Animal implements Jumpping{
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void jump() {
System.out.println("狗学会开车了");
}
}
定义测试类
public class AnimalDemo {
public static void main(String[] args) {
//Cat
Animal a1 = new Cat();
a1.setName("加菲");
a1.setAge(2);
System.out.println(a1.getName()+","+a1.getAge());
a1.eat();
Jumpping j1=new Cat();
j1.jump();
System.out.println("\n");
//Dog
Animal a2=new Dog("旺仔",4);
System.out.println(a2.getName()+","+a2.getAge());
a2.eat();
Jumpping j2=new Dog();
j2.jump();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
