Java面向对象的三大特征(封装,继承,多态)

一.封装

1.概念

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

2.封装原则

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

3.封装好处

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

4.权限修饰符

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

// 定义变量 1.[修饰符] 变量类型 变量名称; 2.[修饰符] 变量类型 变量名称 = 初始值;
  修饰符起到的作用从字面就可以解释,起到一个修饰和限定的作用,可以使用在成员变量之前的修饰符可以是public、protected、private、final、static。

Java面向对象的三大特征(封装,继承,多态)_第1张图片

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拓展:
Java面向对象的三大特征(封装,继承,多态)_第2张图片

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.多态的好处与弊端

  • 好处

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

  • 弊端

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

你可能感兴趣的:(java,多态,封装,编程语言)