[Java] 面向对象的三个特征与含义

简介:

对象 
是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。

类 
是一个模板,它描述一类对象的行为和状态。

1 . 封装性

  将对象的状态信息尽可能的隐藏在对象内部,只保留有限的接口和方法与外界进行交互,从而避免了外界对对象内部属性的破坏。

  Java中使用访问控制符来保护对类、变量、方法和构造方法的访问。 
Java支持4种不同的访问权限。  
 
默认的,也称为default,在同一包内可见,不使用任何修饰符。 
私有的,以private修饰符指定,在同一类内可见。 
共有的,以public修饰符指定,对所有类可见。 
受保护的,以protected修饰符指定,对同一包内的类和所有子类可见。

2. 继承

   java通过继承创建分等级层次的类,可以理解为一个对象从另一个对象获取属性的过程。 
 
类的继承是单一继承,也就是说,一个子类只能拥有一个父类 
下面的做法是不合法的:

public class extends Animal, Mammal{} 

  但是我们可以用多继承接口来实现, 如: 

public class Apple extends Fruit implements Fruit1, Fruit2{}

  继承中最常使用的两个关键字是extends(用于基本类和抽象类)和implements(用于接口)。 
 
注意:子类拥有父类所有的成员变量,但对于父类private的成员变量却没有访问权限,这保障了父类的封装性。 
下面是使用关键字extends实现继承。 

public class Animal{
}

public class Mammal extends Animal{
}

public class Reptile extends Animal{
}

public class Dog extends Mammal{
}

  通过使用关键字extends,子类可以继承父类所有的方法和属性,但是无法使用 private(私有) 的方法和属性。 
我们通过使用instanceof 操作符能够确定一个对象是另一个对象的一个分类。

public class Dog extends Mammal{

   public static void main(String args[]){

      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

结果如下:

true
true
true

Implements关键字使用在类继承接口的情况下, 这种情况不能使用关键字extends。

public interface Animal {}

public class Mammal implements Animal{
}

public class Dog extends Mammal{
}

可以使用 instanceof 运算符来检验Mammal和dog对象是否是Animal类的一个实例。

interface Animal{}

class Mammal implements Animal{}

public class Dog extends Mammal{
   public static void main(String args[]){

      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
} 

运行结果如下:

true
true
true

3.多态

  多态是同一个行为具有多个不同表现形式或形态的能力。 
多态性是对象多种表现形式的体现 
 
比如:我到宠物店说”请给我一只宠物”,服务员给我小猫、小狗或者蜥蜴都可以,我们就说”宠物”这个对象就具备多态性。 

例子
public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

因为Deer类具有多重继承,所以它具有多态性。 
访问一个对象的唯一方法就是通过引用型变量 (编译时变量)。 
引用型变量只能有一种类型,一旦被声明,引用型变量的类型就不能被改变了。 
引用型变量不仅能够被重置为其他对象,前提是这些对象没有被声明为final。还可以引用和它类型相同的或者相兼容的对象。它可以声明为类类型或者接口类型。

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;


所有的引用型变量d,a,v,o都指向堆中相同的Deer对象。

我们来看下面这个例子:

public class Animal {
            public String name = "父类name";
            public void move(){
                System.out.println("父类move");
            }
            public void content(){
                System.out.println("父类content");
            }
}


public class Bird extends Animal{
    public String name = "子类name";
    @Override
    public void move() {
        // TODO Auto-generated method stub
        System.out.println("子类move");
    }
     public void content(){
        System.out.println("子类content");
    }

}
public class Test {
    public static void main(String[] args) {
        Animal a = new Animal();
        System.out.println(a.name);
        a.move();
        a.content();

        System.out.println("----------------------");

        Animal b = new Bird(); //向上转型由系统自动完成
        //编译时变量      运行时变量  
        System.out.println(b.name);
        b.move();
        b.content();

        System.out.println("----------------------");

        Bird c = new Bird();
        System.out.println(c.name);
        c.move();
        c.content();
    }
}

运行结果:

父类name
父类move
父类content
----------------------
父类name
子类move
子类content
----------------------
子类name
子类move
子类content


说明:Bird类继承Animal并重写了其方法。 
因为Animal b = new Bird(),编译时变量和运行时变量不一样,所以多态发生了。可以从最后的运行结果中看出,调用了父类的成员变量name和子类重写后的两个方法。 
上面继承说了,子类可以调用父类所有非private的方法和属性。因为name是一个String的对象,与方法不同,对象的域不具有多态性。通过引用变量来访问其包含的实例变量时,系统总是视图访问它编译时类型所定义的变量,而不是他运行时类型所定义的变量。

  那么问题来了,如果我们把Animal的成员变量换成private,那会不会去调用Bird类的成员变量name来打印输出呢? 
这里写图片描述

也就是说 系统访问的始终是去访问编译时类型所定义的变量。 

  重写定义:子类对父类的允许访问的方法的实现过程进行重新编写!返回值和形参都不能改变。即外壳不变,核心重写!









相关文章
|
9天前
|
Java 编译器
封装,继承,多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性:封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态,继承允许新类扩展现有类的功能,而多态则允许对象在不同情况下表现出不同的行为,这些特性共同提高了代码的复用性、扩展性和灵活性。
封装,继承,多态【Java面向对象知识回顾①】
|
7天前
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
17 4
|
7天前
|
SQL 安全 Java
JAVA代码审计SAST工具使用与漏洞特征
JAVA代码审计SAST工具使用与漏洞特征
19 1
|
9天前
|
Java
接口和抽象类【Java面向对象知识回顾②】
本文讨论了Java中抽象类和接口的概念与区别。抽象类是不能被实例化的类,可以包含抽象和非抽象方法,常用作其他类的基类。接口是一种纯抽象类型,只包含抽象方法和常量,不能被实例化,且实现接口的类必须实现接口中定义的所有方法。文章还比较了抽象类和接口在实现方式、方法类型、成员变量、构造方法和访问修饰符等方面的不同,并探讨了它们的使用场景。
接口和抽象类【Java面向对象知识回顾②】
|
24天前
|
安全 Java Go
面向对象程序设计语言:Java
Java语言语法和C语言和C++语言很接近,很容易学习和使用,Java丢弃了C++中很少使用的、很难理解的、令人迷惑的特性,Java语言不使用指针,而是引用,并提供了自动分配和回收内存空间,使得程序员不必为内存管理而担忧
37 2
|
2月前
|
Java 数据处理 开发者
【Java基础面试十二】、说一说你对面向对象的理解
这篇文章阐述了面向对象是一种以类和对象为基础,通过封装、继承和多态等概念来模拟现实世界中的事物及其相互关系的程序设计方法,它强调以事物为中心进行思考和系统构造,与结构化程序设计相比,更符合人类的自然思维方式。
【Java基础面试十二】、说一说你对面向对象的理解
|
2月前
|
Java
【Java基础面试十三】、面向对象的三大特征是什么?
这篇文章介绍了面向对象程序设计的三大基本特征:封装、继承和多态,其中封装隐藏对象实现细节,继承实现软件复用,多态允许子类对象表现出不同的行为特征。
【Java基础面试十三】、面向对象的三大特征是什么?
|
13天前
|
Java 开发者
Java 面向对象
Java 是一种面向对象的编程语言,通过对象与类的概念组织代码和数据。面向对象编程的核心包括类、对象、继承、多态、封装和抽象。类是对象的蓝图,定义了属性和行为;对象则是类的实例。继承允许子类继承父类的属性和方法,增强代码复用性;多态则支持通过相同接口调用不同类型对象的行为,包括方法重载和重写。封装通过公共方法隐藏对象细节,提高安全性;抽象则对对象特征进行提炼,通过抽象类和接口实现。理解这些概念有助于设计高效、可维护的 Java 应用程序。
|
20天前
|
Java 开发者
Java编程之旅:探索面向对象的力量
【9月更文挑战第16天】在编程的世界中,Java以其强大的面向对象编程特性而闻名。本文将带你走进Java的世界,一起探索类与对象的奥秘,学习如何通过封装、继承和多态性构建健壮的软件系统。无论你是初学者还是有经验的开发者,本文都旨在提供实用的代码示例,帮助你提升Java技能。准备好开始这段旅程了吗?让我们启程吧!
|
2月前
|
Java 开发者 C++
下一篇
无影云桌面