Java（面向对象入门之三大特性）

在java面向对象入门中，我们主要学习这三大主要内容

• 封装

• 继承

• 多态

1.封装

1.1信息隐藏

信息隐藏是java中对类的一种保护机制，将一个类的具体实现细节隐藏起来，隐藏通常指的是使用private修饰符对属性或者方法修饰，使得外界无法随意访问该类中的成分。

​ 对于一些属性来说，如果对外公开，则外界一旦获取到该类的实例(对象)，即可对该公开的属性进行随意访问甚至修改，从而会造成一些不要的安全问题。

1.2 Setter&Getter方法

将类中的属性设置为private之后，外界无法访问，但是可以通过提供公开的方法对这些私有的属性进行访问。让外界访问方法的可控性要远远高于直接让外界访问属性；对于上述的操作，Java中提供了两种用于对属性操作的方法：

• setter
• getter

方法代码如下：

public class People {

	private String idCard;
	private String name;
	private int age;
	private String sex;
	private boolean marry;
	
	public String getIdCard() {
		return idCard;
	}
	public void setIdCard(String idCard) {
		this.idCard = idCard;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		if(age > 18) {
			age = 18;
		}
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	/**
	 * boolean类型属性的get方法叫isXXX
	 * @return
	 */
	public boolean isMarry() {
		return marry;
	}
	public void setMarry(boolean marry) {
		this.marry = marry;
	}
	
}

1.3 this关键字

this关键字在一个类中用于表示"当前对象”；this一般用于一个类的成员方法、构造器或者游离块中，作用于调用当前类的构造器，属性和其他方法
介绍代码如下：

public Dog() {
        //		构造器中如果调用了其他构造器，则调用代码必须位于最前端
		//		System.out.println("---");
		//调用包含String类型参数的构造器
		this("来福");
	}

2.继承（extends）

继承是面向对象程序设计中另一个重要的特征，继承即由一个类从另一个通过extends关键字继承，被继承的类称之为父类(也叫超类)，继承的类称之为子类（扩展类）；继承可以使得类的**扩展性提高**，**减少重复代码**的编写。

语法：

[<修饰符>] class 子类 extends 父类 {
    
}

实例:

父类Father：

public class Father {

	public String name;
	public int age;
	
	public void coding() {
		System.out.println(name + "超级会写代码");
	}
	
	public void love(){
		System.out.println("情场高手!!!!");
	}
	
}

子类Son:

public class Son extends Father{

	//通过代码表现：动物 猫 老鼠之间的关系
	public static void main(String[] args) {
		Son s = new Son();
		s.name = "刘德华";
		s.coding();
		s.love();
	}
}

2.1 继承优点

1. 子类可以直接通过对象调用父类中的非私有元素
2. 子类还可以在父类的基础上扩展新的功能

2.2 继承注意事项

• 子类只能继承父类的属性和方法，不能继承构造器
• 子类对象构造之前会先执行父类的构造器（如果存在多重继承，则从最顶层父类构造器开始执行）
• 一个父类可以存在多个子类，但是一个子类只能存在一个父类
• Java不允许多继承，但是支持多重继承
• 被protected修饰的元素可以在子类中被访问（即便父类和子类不在同一个包）

2.3 super关键字

super关键字用于在子类中调用父类的元素:

• 构造器
• 属性
• 方法

使用案例：

public class Animal {

    String name = "旺财";
    double weight = 10 ;

    public Animal(String name) {
        //		this.name = name;
    }

    public void eat() {
        System.out.println("动物进食");
    }

    public void bark() {
        System.out.println("咆哮");
    }
}

public class Dog extends Animal{

    public Dog(String name) {
        //调用父类构造器
        super(name);
    }

    public void play() {
        //调用父类方法
        super.eat();
        super.bark();
		//调用父类属性
        System.out.println("我叫：" + super.name);
    }

    public static void main(String[] args) {
        Dog d = new Dog("来福");
        d.play();
    }

}

3.多态

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

3.1多态的优点

• 1. 消除类型之间的耦合关系
• 2. 可替换性
• 3. 可扩充性
• 4. 接口性
• 5. 灵活性
• 6. 简化性

3.2多态存在的三个必要条件

• 继承
• 重写
• 向上转型

3.2.1继承：

在多态中必须存在有继承关系的子类和父类。

3.2.2重写：

子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

3.2.3向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

3.3多态的实现方式

• 重写：
  我们将介绍在 Java 中，当设计类时，被重写的方法的行为怎样影响多态性。
  我们已经讨论了方法的重写，也就是子类能够重写父类的方法。
  当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
  要想调用父类中被重写的方法，则必须使用关键字 super。
• 接口

1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。

2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。

• 抽象类和抽象方法