Java-你对面向对象的理解

面向对象概述：面向对象是一种编程范式，它将程序中的数据和操作数据的方法组织在一起，形成对象。对象是类的实例，类是对具有相同属性和行为的对象的抽象描述。在面向对象的编程中，对象是程序的基本单元，通过封装、继承和多态等特性来实现代码的重用性、可维护性和灵活性。

 

面向对象三大特性包括封装、继承和多态：

 

封装：封装将数据和操作数据的方法封装在一起，隐藏了内部的实现细节，只暴露必要的接口给外部使用。这样可以提高代码的安全性和可维护性。

 

封装原则：

              • 将不需要对外提供的内容都隐藏起来。

              • 把属性都隐藏，提供公共方法对其访问。

 

Java中可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

 

private：类中限定为private的成员，只能被这个类本身访问。如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。

default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。

protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。

public：类中限定为public的成员，可以被所有的类访问。

 

class Student {

private String name;//声明属性 ,并设为私有类型，起到封装的作用

private int age;

       public Student(String name,int age ) { //构造函数，分别给name、age赋值

              this.name= name;// ：this代本类对象的引用

              this.age= age;

       }

 

       public String getName() { //设置getter方法，因为变量设为了私有，对象无法访问类中的属性，需要用getter方法获取变量

              return name;

       }

 

       public void setName(String name) { //设置setter方法，因为变量设为了私有，对象无法访问类中的属性，需要用setter方法给变量赋值

              this.name = name;

       }

 

       public int getAge() {

              return age;

       }

 

       public void setAge(int age) {

              this.age = age;

       }

}

 

 

继承：继承允许一个类继承另一个类的属性和方法，使得代码的重用性更高。子类可以继承父类的属性和方法，并且可以在此基础上进行扩展或修改。

Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。

       继承的好处是：

              • 实现了代码的复用。

              • Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。

              • 子类不能继承父类中访问权限为private的成员变量和方法。

              • 子类可以重写父类的方法，即命名与父类同名的成员变量。

 

       Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

              • 访问父类被隐藏的成员变量，如：super.variable;

              • 调用父类中被重写的方法，如：super.Method([paramlist]),super())调用父类构造方法;

              • 调用父类的构造函数，如：super([paramlist]);

 

       super和this的用法相同：this代表本类应用 ；super代表父类引用 。当子父类出现同名成员时，可以用super进行区分 ，子类要调用父类构造函数时，可以使用super语句。

       在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

 

class Fu { //父类

       int age=20;

       String name="fu";

       public void show() {

       System.out.println("姓名："+name+" 年龄:"+age);

       }

 }

class Zi extends Fu{//子类Zi继承了父类Fu

       int score=90;//增加了新的属性

int age= super.age+1;//使用super标记父类中的元素，修改了Fu中age的值

       public void show() {//重写了父类中的方法（ 覆盖时，子类方法权限一定要大于等于父类方法权限，静态只能覆盖静态。）

System.out.println("姓名："+name+" 年龄:"+age+" 分数:"+ score);// Zi继承了Fu，所以Fu中的属性name和age在Zi可以直接使用

       }

}

 

public class Demo{

        public static void main(String[] args) {

                  Fu fu = new Fu();//声明一个Fu对象

                  Zi zi =new Zi()//声明一个Zi对象

                    Fu.show();

                    Zi.show();

       }

    }

 

多态：多态是指同一个方法在不同的对象上具有不同的行为。通过多态，可以实现方法的重写和重载，提高代码的灵活性和可扩展性。

在Java中，面向对象的思想贯穿于整个语言的设计和使用过程中。Java提供了类和对象的概念，通过定义类来创建对象，并通过对象来调用类中的方法和访问类中的属性。Java还支持封装、继承和多态等面向对象的特性，使得程序的设计和实现更加灵活和可扩展。

 

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

 

比如：

class Father{

　　public void func1(){

　　func2();

　　}

　　public void func2(){//这是父类中的func2()方法，因为下面的子类中重写了该方法

//所以在父类类型的引用中调用时，这个方法将不再有效

//取而代之的是将调用子类中重写的func2()方法

　　System.out.println("AAA");

　　}

　}

　　class Child extends Father{

　　//func1(int i)是对func1()方法的一个重载

　　//由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用

　　//所以在下面的main方法中child.func1(68)是不对的

　　public void func1(int i){

　　System.out.println("BBB");

　　}

　　//func2()重写了父类Father中的func2()方法

　　//如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法

　　public void func2(){

　　System.out.println("CCC");

　　}

　}

　　public class PolymorphismTest {

　　public static void main(String[] args) {

　　Father child = new Child();

　　child.func1();//打印结果将会是什么？

　　//此方法是错误的，父类中没有此方法。

　//　child.func1(68)

　　}

　}

 

当然，多态也有弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

 

 

面向对象编程（OOP）：

 

面向对象编程其实是一种设计思想，在程序设计过程中把每一部分都尽量当成一个对象来考虑，以实现软件系统的可扩展性、可维护性和可扩展性。

 

面向对象的优点：

 

可扩展性： 指新的功能可以很容易地加入到系统中来，便于软件的修改。

可维护性： 能够将功能与数据结合，方便管理。

可重用性： 代码重复使用，减少代码量，提高开发效率。下面介绍的面向对象的三大核心特性（继承、封装和多态）都围绕这个核心。