Java基础学习之面向对象（4）

目录

• 1.面向对象概述
  • 1.1.类与对象的关系
  • 1.2.类的具体描述
• 2.面向对象的三大特性
  • 2.1.继承
  • 2.2.多态
  • 2.3.封装

1.面向对象概述

1.1.类与对象的关系

有对象吗，没有的话我给你new一个！

对象顾名思义就是一个个的个体，当所有的个体，例如人的总称为人类，这一类的生物或者物品。人类是对人这种个体的抽象化，不会说你是个人类，而是说你是个人，所以人就是人类的具体实现。

简而言之，类是对象的抽象化，对象是类的具体实现。

正所谓Java主打的万物皆对象。

public class Person{
	private String name;
	private int age;
	private String gender;

	public Person(String name, int age, String gender){
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	public void say(){
		System.out.println("hello");
	}

	public static void main(String[] args){
		Person p = new Person("张三", "22", "男");
		p.say();
	}
}

在上面代码中，类Person就是人的一种抽象化，每个人都有姓名、年龄、性别等属性和一些动作，比如说等。在main方法中我们使用关键字new将类具体化为一个对象，这个对象名张三、22岁、男性，并且说了hello。

1.2.类的具体描述

类Person中有属性name、age、gender等，方法say等。还有个比较特殊的方法public Person(...)，这个方法就是类的构造器。

构造方法又成为构造器，和一般的方法不同的是：

• 没有返回值（没有返回类型，也没有void）
• 方法名和类名一样

一个类可以有多个构造方法，这是后面要说到的重载。

2.面向对象的三大特性

面向对象程序设计的优点：

• 可扩展
• 可重用

缺点：

• 复杂程度较高

2.1.继承

继承就是子类继承父类的特征和行为，得到父类的实例变量和方法。例如猫和狗都是动物，可以继承动物的一些通用特征和行为。

为什么需要继承？

如果没有继承，当我们写猫和狗的类时：

public class Cat {
	private String name;
	private int age;
	public Cat(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println(name+"吃东西");
	}
	public void sleep() {
		System.out.println(name+"睡觉");
	}
}

public class Dog {
	private String name;
	private int age;
	public Dog(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println(name+"吃东西");
	}
	public void sleep() {
		System.out.println(name+"睡觉");
	}
}

发现我们写了很多重用的代码，比如属性name、age和方法eat、sleep等。

如果使用继承代码将变成怎么样呢？

public class Animal {
	private String name;
	private int age;
	public Animal(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println(name+"吃东西");
	}
	public void sleep() {
		System.out.println(name+"睡觉");
	}
}

public class Cat extends Animal {
	public Cat(String name, int age) {
		super(name, age);
	}
}

public class Dog extends Animal {
	public Dog(String name, int age) {
		super(name, age);
	}
}

我们发现只需要写一个父类，子类就具有父类的属性和方法了，这样我们就不需要写那么多重复的代码了，提高了代码的复用性。

总结以下：

• 子类拥有父类的非private的属性、方法，这里private之前说过，所修饰的只能在同一个类中可见
• 子类可以对父类进行扩展
• 子类可以重写父类的方法
• Java中不支持多继承

重写和重载：

• 重写（override）：猫和鱼都继承了动物类，如果动物类有一个方法叫run()，对于猫来说使用四肢奔跑，对于鱼来说使用鱼鳍游动。这时我们需要重写父类的方法：

public class Person {
	public void run() {
		System.out.println("动物跑起来了");
	}
}

public class Cat {
	@Override
	public void run() {
		System.out.println("猫跑起来了");
	}
}

public class Fish {
	@Override
	public void run() {
		System.out.println("鱼游起来了");
	}
}

• 重载（overload）：同一个类中，方法名相同，参数不同，返回值可以相同或不同。

public class Animal {
	public void test() {}
	public void test(int num) {}
	public void test(String str) {}
	public void test(int num, String str) {}
	public void test(String str, int num) {}
}

2.2.多态

多态就是同一个行为具有不同的表现形式。

多态分类：

• 编译时多态：静态的，主要是方法的重载
• 运行时多态：动态绑定实现的，例如父类的引用指向子类的对象

实现多态的必要条件：

• 继承
• 重写
• 向上转型：父类的引用指向子类的对象

多态的优点：

• 消除耦合关系
• 可扩展性
• 简单易用

多态的实现方式：

• 重写
• 接口：可多实现接口，解决单继承的缺陷

public interface Animal {
	public void run();
}

public class Cat implements Animal {
	@Override
	public void run() {
		System.out.println("猫趴");
	}
}

• 抽象类和抽象方法：抽象类中可以存在非抽象方法，抽象方法一定存在于抽象类中，抽象方法只声明不实现，继承的子类必须实现抽象类中的抽象方法

public abstract Animal {
	public abstract void run();
}

public class Cat extends Animal {
	@Override
	public void run() {
		System.out.println("猫趴");
	}
}

2.3.封装

封装将类的实现细节隐藏，以保证程序和数据不受外部干扰，保护信息。

优点：

• 保护类中的东西，隐藏信息，实现细节
• 良好的封装可以减少耦合
• 类内部结构可以自由修改
• 可以精确控制类成员

public class Person {
    private String name;
    private int 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;
    }
}

将类的属性设置为private，然后对外提供public方法进行赋值和取值。