java 面向对象小结

java是一门面向对象的编程语言,他具有以下三大特性:

• 继承
• 封装
• 多态

---

继承

继承,就是子类继承父类的特征和行为,并拓展

1.继承格式

java用extends和implements关键字来实现继承
如果没有使用这两个关键字实现继承,则所有类默认继承java.lang.Object, Object是所有类的父类
java的继承是单一继承,一个类只能继承一个父类,所以extends只能继承一个类

public class father{
}
public class son extends father{        //子类继承父类
}

implements关键字可以变相实现多继承,但只能用于继承接口

public interface A{
}
public interface B{
}
publuc class C implements A,B{          //C继承A,B两个接口
}

2.继承的特性

• 子类拥有父类的非private属性和方法
• 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展
• 子类可以重写父类方法
• java是单继承,但可以多重继承
• 提高类之间的耦合性

3.super与this

super:用来引用当前对象的父类
this:指向当前对象自己的引用

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

输出结果:

animal : eat
dog : eat
animal : eat

4.final

final修饰的类表示最终类,无法被继承

public final class A{
}

final修饰的方法不能被子类重写

public class A{
    public final void eat(){
        System.out.print("吃");
    }
}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

---

封装

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

1.实例

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

• 以上实例使用private来限制外部对内部属性的可见性
• 为属性提供对外的公共方法访问,setter和getter,因此任何要访问类中私有成员变量的类都要通过这些getter和setter方法
• 使用this关键字是为了解决实例变量(private String name)和局部变量(setName(String name))之间的同名冲突

2.优点

• 良好的封装能减少耦合
• 类内部的结构能自由修改
• 可以对成员变量进行精确控制
• 隐藏信息,实现细节

---

多态

接口的多种不同实现方式即多态.

1.多态的必要条件

• 继承
• 重写
• 父类引用指向子类对象

2.多态的实现方式

1.重写和重载

重写
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变

class Dog{
    public void bark(){
        System.out.print("woof");
    }
}
class Hound extends Dog{
    public void bark(){             //方法名,参数与父类相同
        System.out.print("bowl");   //重写bark方法
    }
}

方法的重写规则

• 参数列表,返回类型必须完全与被重写方法相同
• 访问权限不能比父类中的被重写方法更低,如:父类的方法是public,子类不能是protected或private
• 父类的成员方法只能被他的子类重写
• final修饰的方法不能被重写
• static修饰的方法不能被重写,但能再次声明
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法
• 构造的方法不能被重写

注:当子类中调用父类的被重写方法是,要使用super

重载
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

class Dog{
    public void bark(){
        System.out.print("woof");
    }
    public void bark(String woof){// 方法名相同,参数不同,即重载bark方法
        System.out.print(woof);
    }
}

重载规则

• 被重载的方法必须改变参数列表(参数个数或类型不一样)
• 被重载的方法可以改变返回类型,访问修饰符
• 无法以返回值类型作为重载函数的区分标准。

2.抽象类和抽象方法

• 抽象类不能被实例化,只有抽象类的非抽象子类可以实例化
• 抽象类不一定包含抽象方法,但有抽象方法的类一定是抽象类
• 抽象类中的抽象方法只是声明,没有方法体
• 构造方法,类方法(static修饰的方法),不能声明为抽象方法
• 抽象类的子类必须实现父类中的方法,除非也声明为抽象类

3.接口

接口，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法

接口特性

• 接口中每一个方法是隐式抽象的(只能是public abstract)
• 接口中的变量会被隐式指定为public static final
• 接口只能由接口的实现类来实现接口中的方法

抽象类与接口的区别

• 抽象类中的方法可以有方法体,接口没有
• 抽象类中的成员变量可以是各种类型,接口的成员变量只能是public static final
• 接口中不能含有静态代码块和静态方法(static),抽象类可以
• 一个类只能继承一个抽象类,但可以实现多个接口