面向对象的三大特征

一、封装

1、封装含义

所谓类的封装是指在定义一个类时，将类中的属性私有化，即用private关键字来修饰，为了能让外界访问私有属性，需要提供一些public修饰的公共方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。
举例：

import java.util.*;
class Student {
    private String name;
    private String sex;
    private int age;
    //下面是公有的getXxx()和setXxx()方法
    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    public void introduce(){
        //打印属性name和age的值
        System.out.println( name +"是男生"+age +"岁！");
    }
}
public  class TestDemo {
    public static void main(String args[]) {
        Student per = new Student();// 声明并实例化对象
        Student stu = new Student(); //创建学生对象
        stu.setName("张三"); //利用set方法为name属性赋值
        stu.setAge(18);  //利用set方法为age属性赋值
        System.out.println(stu.getName());//利用get方法获取Name的值
        System.out.println(stu.getAge());//利用get方法获取Age的值
        //调用对象的introduce()方法
        stu.introduce();
    }
}

运行结果：

张三
18
张三是男生18岁！

Process finished with exit code 0

2.四种权限访问修饰符

封装性的体现，需要权限修饰符来配合。

1. Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
2. 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
   具体权限如下：
   
   拓展（缺省定义方式）：

class TestDemo {
    //“缺省”修饰的方法
    void test(){
        System.out.println("hello world");
    }
    public static void main(String[] args) {
        TestDemo dt =new TestDemo();
        dt.test();
    }
}

二、继承

1.继承的概念

继承的主要作用在于，在已有基础上继续进行功能的扩充。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

2.类的继承格式

类的继承格式
class 父类 {
}
 
class 子类 extends 父类 {
}

3.继承的好处

1. 继承的出现减少了代码冗余，提高了代码的复用性。
2. 继承的出现，更有利于功能的扩展。
3. 继承的出现让类与类之间产生了关系，提供了多态的前提
   我们可以通过下面一段代码来深入理解:

package study.day_11;
class Person1 {
   String name;
   int age;

   public Person1() {
   }

   public Person1(String name, int age) {
       this.name = name;
       this.age = age;
   }
   public  void eat(){
       System.out.println("吃饭");
   }
   public void sleep(){
       System.out.println("睡觉");
   }
}
class Student1 {
   String name;
   int age;
   String major;
   public Student1(){

   }
   public Student1(String name, int age, String major) {
       this.name = name;
       this.age = age;
       this.major = major;
   }
       public  void eat(){
       System.out.println("吃饭");
   }
   public  void sleep(){
       System.out.println("睡觉");
   }
   public  void study(){
       System.out.println("学习 ");
   }
}
public class Person{
   public static void main(String[] args) {

   }
}

从以上可看出，含有大量重复的代码，java语言一般不允许大量重复的代码出现，这段代码不仅从代码上重复，而且从概念上讲学生一定是人，只是学生类描述的范围小，具备更多的属性和方法，这个时候想要消除结构定义上的重复，就要用到继承。
所以可将上述代码改为：

class Person1 {
    String name;
    int age;

    public Person1() {
    }

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public  void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
class Student1 extends Person1{
    String major;//专业
    public Student1(){

    }
    public Student1(String name, int age, String major) {
        this.name = name;
        this.age = age;
        this.major = major;
    }
    public  void study(){
        System.out.println("学习 ");
    }
}
public class TestDemo{
    public static void main(String[] args) {

        System.out.println("Student类*************");
        Student1 s1=new Student1();
        s1.name="张三";
        s1.age=18;
        s1.major="Java语言";
        System.out.println("姓名："+s1.name+"年龄："+s1.age+"专业："+s1.major);
    }
}

运行结果：

Student类*************
姓名：张三年龄：18专业：Java语言

Process finished with exit code 0

4.继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，每个子类只有一个父类。
• 子类直接继承的父类，称为：直接父类，间接继承的父类称为：间接父类。子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

5.继承关键字

（1）super 关键字

super关键字的使用：

1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器

格式：

1.我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
2.特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

super调用构造器

1.我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
2 ."super(形参列表)"的使用，必须声明在子类构造器的首行！
3.我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二选一，不能同时出现
4. 在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
5.在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器
举例：

class people {
    void eat() {
        System.out.println("人吃饭");
    }
}
class Men extends people {
    void eat() {
        System.out.println("张三吃饭");
    }
    void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
    }
}
public class TestDemo11_4 {
    public static void main(String[] args) {
        people a = new people();
        a.eat();//打印people父类中eat方法
        Men d = new Men();
        d.eatTest();//打印子类Men中eatTest方法
    }
}

运行结果：

人吃饭
张三吃饭
人吃饭

（2）final关键字

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

*声明类：

final class 类名 {//类体}

*声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体};

三、多态

1.什么是多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。
打印这个行为具有彩色打印和黑白打印两种不同的表现形式。

2.多态的使用

1.对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
2. 多态的使用：虚拟方法调用：

• 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
• 总结：编译，看左边；运行，看右边。

3.多态性的使用前提： ① 类的继承关系 ② 方法的重写
4. 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

以下是一个多态实例的演示，详细说明请看注释：
Person类：

package study.day_13.java;

public class Person {
   String name;
   int age;
   
   int id = 1001;
   
   public void eat(){
   	System.out.println("人：吃饭");
   }
   
   public void walk(){
   	System.out.println("人：走路");
   }
   
}

Man类：

package study.day_13.java;

public class Man extends Person{
	
	boolean isSmoking;
	
	int id = 1002;
	
	public void earnMoney(){
		System.out.println("男人负责挣钱养家");
	}
	
	public void eat(){
		System.out.println("男人多吃肉，长肌肉");
	}
	
	public void walk(){
		System.out.println("男人霸气的走路");
	}

}

Woman类：

package study.day_13.java;

public class Woman extends Person{
	
	boolean isBeauty;
	
	public void goShopping(){
		System.out.println("女人喜欢购物");
	}
	
	public void eat(){
		System.out.println("女人少吃，为了减肥");
	}
	
	public void walk(){
		System.out.println("女人窈窕的走路");
	}
}

测试类：

public class PersonTest {
	public static void main(String[] args) {
		System.out.println("Person类eat方法**********");
		Person p1 = new Person();
		p1.eat();
		System.out.println("Man类方法*************");
		Man man = new Man();
		man.eat();
		man.earnMoney();
		
		//*************************************************
		System.out.println("多态*******************");
		//多态：子类的对象赋给父类的引用（父类的引用指向子类的对象）
		Person p2 = new Man();
		//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
		p2.eat();
		p2.walk();
		/**
		 *p2.earnMoney();
		 *有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型
		 * 编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
		 **/
	}
}

运行结果：

Person类eat方法**********
人：吃饭
Man类方法*************
男人多吃肉，长肌肉
男人负责挣钱养家
多态*******************
男人多吃肉，长肌肉
男人霸气的走路