Java-面向对象基础

一、继承
1、继承的格式

class 父类 {
}
 
class 子类 extends 父类 {
}

2、继承的特性

• 子类拥有父类非 private 的属性、方法
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
• 子类可以用自己的方式实现父类的方法，即重写
• Java 的继承是单继承，但是可以多重继承

3、继承的关键字

• extends关键字

public class Animal {
    private String name;

    public void eat(){
        //方法内容
    }
}

public class Dog extends Animal{

}

• implements关键字

public interface A {
    public void eat();
}
 
public interface B {
    public void sleep();
}
 
public class C implements A,B {
}

• super关键字
  实现对父类成员的访问，引用当前对象的父类
• this关键字
  指向自己的引用

public class Animal {
    public void eat(){
        //方法内容
    }
}

public class Dog extends Animal{
	public void eat(){
        //方法内容
    }
	public void eatTest(){
        super.eat();// super 调用父类方法
        this.eat();// this 调用自己的方法
    }
}

• final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

//声明类
final class 类名 {
	//类体
}

//声明方法
修饰符 final 返回值类型 方法名(){
	//方法体
}

//声明变量
修饰符 final 变量类型 变量名;

二、抽象
1、抽象类

• 定义
  如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
• 特性
  抽象类不能实例化对象
  抽象类必须被继承，才能被使用

public abstract class Animal
{
   private String name;
   public Animal(String name)
   {
      this.name = name;
   }
}

2、抽象方法

• 定义
  一个类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么可以在父类中声明该方法为抽象方法

• 特性
  抽象方法只包含一个方法名，而没有方法体，方法名后面直接跟一个分号
  如果一个类包含抽象方法，那么该类必须是抽象类
  任何子类必须重写父类的抽象方法，或者声明自身为抽象类
  构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法

public abstract class Animal
{
   	private String name;
   	public abstract String animalName();
}

public class Dog
{
	private String name;
   	public String animalName(){
		return "HH";
	}
}

三、封装
1、定义
封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法
2、特性

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

3、实例
最熟悉的封装类的例子

public class Animal {
    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

四、多态
1、定义
多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作
2、特性

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

3、实例

public class Test {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法

        Animal a = new Cat();  // 向上转型
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型
        c.work();               // 调用的是 Cat 的 work
    }

    public static void show(Animal a)  {
        a.eat();//父类抽象方法可直接调用、子类已实现
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog  d = (Dog)a;
            d.work();
        }
    }
}

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}

文章仅作为个人学习整理