Java面向对象的三大特征（封装，继承，多态）

一.封装

1.概念

   封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。

2.封装原则

  将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法

3.封装好处

  1.通过方法来控制成员变量的操作，提高了代码的安全性
  2.把代码用方法进行封装，提高了代码的复用性
  3.类内部的结构可以自由修改。隐藏信息，实现细节。

4.权限修饰符

  当我们在一个类中定义成员变量时，会指定一个变量的类型，除此之外，还会有修饰符的部分，在此给出定义成员变量的规范格式：

// 定义变量 1.[修饰符] 变量类型 变量名称; 2.[修饰符] 变量类型 变量名称 = 初始值;

  修饰符起到的作用从字面就可以解释，起到一个修饰和限定的作用，可以使用在成员变量之前的修饰符可以是public、protected、private、final、static。

5.封装代码

```java
代码演示：
/*学生类*/

public class Student {
     
     private int number;//private修饰三个属性
     private int state;
     private int score;
     public Student (){
     

     }//无参构造器
     public Student(int number,int state,int score){
     
              this.number=number;
              this.state=state;
              this.score=score;
     }//有参构造器
     /*下面是Student类提供的get() set()方法外界可以通过他们访问！*/
     public void setNumber(int number){
     
        this.number=number;
     }
     public int getNumber(){
     
         return number;
     }
    public void setState(int state){
     
        this.state=state;
    }
    public int getState(){
     
        return state;
    }
    public void setScore(int score){
     
        this.score=score;
    }
    public int getScore(){
     
        return score;
    }
}
===============================
/*测试类*？
public class StudentDemo {
     
    public static void main(String[] args) {
     
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

二.继承

1.概述

  继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

2.继承优点

1.继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用；
2.在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段或方法；
3.可以在子类中声明一个在父类中没有的新字段和方法；
4.可以在子类中编写一个父类当中具有相同名的新实例方法，这称为“方法重写”或“方法覆盖”；
5.可以在子类中编写一个调用父类构造方法的子类构造方法，既可以隐式地实现，也可以通过使用关键字super来实现。

3.变量访问特点

在子类方法中访问一个变量，采用的是就近原则。

1. 子类局部范围找
2. 子类成员范围找
3. 父类成员范围找
4. 如果都没有就报错(不考虑父亲的父亲…)

4.代码演示

//代码演示：
class teacher{
                  //声明一个teacher类为父类
	String name;      	   //定义父类的成员变量name、age   
	int age;
	void show(){
                //定义父类成员方法，将成员变量输出
		System.out.println(name); 	  
		System.out.println(age); 
	}
}
class Student extends teacher {
          //声明一个Student类为子类并继承父类
}
public class myfirst {
     
	public static void main(String[] args) {
     
	System.out.println("学生");
	Student student=new Student();     //声明一个Student类的实例对象student
	student.name="Tom";                //子类调用父类的成员变量name并赋值
	student.age=19;                    //子类调用父类的成员变量age并赋值
	student.show();                    //子类调用父类的成员方法show
	}
}

5.继承中的关键字

1、 extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
2、implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public class C implements A,B {
     
}

3、super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
this关键字：指向自己的引用。
4、final关键字

• fianl关键字的作用
  • final代表最终的意思，可以修饰成员方法，成员变量，类
• final修饰类、方法、变量的效果
  • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
  • final修饰方法：该方法不能被重写
  • final修饰变量：表明该变量是一个常量，不能再次赋值
    final不能修饰构造器
    final与static搭配使用不会导致类加载

Final拓展：

5.static关键字
static的访问特点

• 非静态的成员方法
  • 能访问静态的成员变量
  • 能访问非静态的成员变量
  • 能访问静态的成员方法
  • 能访问非静态的成员方法
• 静态的成员方法
  • 能访问静态的成员变量
  • 能访问静态的成员方法
• 总结成一句话就是：
  • 静态成员方法只能访问静态成员

6.继承的注意事项

Java中继承的注意事项

1. Java中类只支持单继承，不支持多继承
   错误范例：class A extends B, C { }
2. Java中类支持多层继承

7.重写

• 方法重写的注意事项

1. 私有方法不能被重写(父类私有成员子类是不能继承的)
2. 子类方法访问权限不能更低(public > 默认 > 私有)
   3.代码实现

代码：
public class InheritenceTest {
     
    public static void main(String[] args) {
     
        Dog dog = new Dog();
        dog.run();
    }
}
 
class Animal {
     
    public void run() {
     
        System.out.println("animal is running");
    }
}
 
class Dog extends Animal {
     
    public void run() {
     
        System.out.println("Dog is running");
        super.run();//调用父类的run方法
    }
  }
}// 方法重写与方法重载之间的关系：重载发生在同一个类内部的两个方法或多个方法。重写发生在父类和子类之间。

三.多态

1.多态概述

• 什么是多态

  ​ 同一个对象，在不同时刻表现出来的不同形态

• 多态的前提

  • 要有继承或实现关系
  • 要有方法的重写
  • 要有父类引用指向子类对象

2.代码演示

代码：
/*接口类*/
public interface Jumpping {
     
    void Jump();
    }
/*测试类*/
public class AnimalDemo {
     
    public static void main(String[] args) {
     
        Jumpping j=new Cat();//父类引用指向子类也叫向上转型
        j.Jump();
        }
   }

3.成员访问特点

成员访问特点

• 成员变量

  ​ 编译看父类，运行看父类

• 成员方法

  ​ 编译看父类，运行看子类

4.多态的转型

• 向上转型

  ​ 父类引用指向子类对象就是向上转型
  例子：Animal a=new Cat()

• 向下转型

  ​ 格式：子类型 对象名 = (子类型)父类引用;
  例子：Cat c=(Cat) Animal

5.多态的好处与弊端

• 好处

  ​ 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

• 弊端

  ​ 不能使用子类的特有成员