java 面向对象优势_Java面向对象

最新推荐文章于 2023-06-03 21:53:50 发布

意博思诺意大利留学

最新推荐文章于 2023-06-03 21:53:50 发布

阅读量295

点赞数

文章标签： java 面向对象优势

本文链接：https://blog.csdn.net/weixin_42461108/article/details/115045443

版权

文章目录

面向对象

java是一门面向对象的语言，面向对象最重要的三个特性封装，继承和多态。

java的封装

在面向对象程式设计方法中，封装(英语：Encapsulation)是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问封装的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

优点

通过良好的封装可以减少耦合。

类的内部结构可以自由修改，而不用修改那些调用我们代码的程序片段。

对成员变量更加精确的控制。

隐藏信息和实现细节。

Java实现封装的步骤

java中方法就是一封装。

通过使用访问控制符private来修改属性的可见性，限制外部对属性的访问。

一个简单实例：

//使用private关键字隐藏了属性

public class Person {

private String name;

private int age;

}

//实例对象直接访问会报错

public class demoMain {

public static void main(String[] args) {

Person person = new Person();

person.name = "java";//报错

person.age = 15;//报错

}

public class Person {

private String name;

private int age;

//为私有属性添加Getter和Setter方法，进行访问控制

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {//Setter方法可以用于对传入的数据进行合法性判断

if(age>0&&age<100){

this.age = age;

}else {

System.out.println("数据异常！");

}

public class demoMain {

public static void main(String[] args) {

Person person = new Person();

// person.name = "java";

// person.age = 15;

//通过类的成员方法访问private 修饰的成员变量

person.setName("java");

person.setAge(15);

System.out.println(person.getName()+":"+person.getAge());//java:15

}

Java的继承

继承是java面向对象编程技术的一块基石，继承就是子类继承父类的特征和行为，使得子类对象(实例)具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承就是父类对子类的共性抽取。父类更通用，子类更具体。

继承格式：class 子类名 extends 父类名{}

一个简单的继承实例：

public class Animal {

private String name;

public Animal() {

}

public Animal(String name) {

this.name = name;

}

public void eat(){

System.out.println("父类的eat方法");

}

public void work(){

System.out.println("父类的work方法");

}

public class Cat extends Animal{

//子类没有重写父类的eat()

@Override

public void work() {//子类可以重写父类的方法

System.out.println("猫抓老鼠");

}

public class demoMain {

public static void main(String[] args) {

Cat cat = new Cat();

cat.setName("猫");//子类无法继承父类中private修饰的私有属性

System.out.println(cat.getName());

cat.eat();//子类没有重写父类的eat()方法，则向上找父类

cat.work();

}

猫

父类的吃方法

猫抓老

继承的类型

需要注意的是 Java 不支持多继承，但支持多重继承。

继承的特性

子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

提高了类之间的耦合性(继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差)

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口内容补充

从Java 8开始，接口里允许定义默认方法。格式:

public default void methodDefault() {//接口中的默认方法

System.out.println("新增加的默认方法");

}

接口的默认方法，可以通过接口实现类对象，直接调用。

接口的默认方法,也可以被接口实现类进行覆盖重写。

接口当中的默认方法，可以解决接口升级的问题。

从Java 8开始，接口当中允许定义静态方法。格式:

static void methodStatic() {//接口中的静态方法

System.out.println("接口的静态方法");

}

注意事项:不能通过接口实现类的对象来调用接口当中的静态方法。

正确用法:通过接口名称，直接调用其中的静态方法。

格式:

接口名称.静态方法名(参数);

问题描述:

我们需要抽取一个共有方法，用来解诀接口中两个默认方法或静态方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。

解决方案:

从Java 9开始，接口当中允许定义私有方法。

1．普通私有方法，解决多个默认方法之间重复代码问题格式:

private void methodCommon() {//解决默认方法重复代码

System.out.println("方法体");

}

2．静态私有方法，解决多个静态方法之间重复代码问题格式:

private static void methodCommon1() {

System.out.println("方法体");

}

public interface MyInterface {

public static final int NUM_OF_INTERFACE = 10;//接口中的常量使用public static final修饰，大写下划线连接，并赋值

void method1(); //接口中的抽象方法

void method2(); //接口中的抽象方法

default void methodDefault() {//接口中的默认方法

System.out.println("新增加的默认方法");

}

private static void methodStatic() {//接口中的静态方法

System.out.println("接口的静态方法");

}

default void methodDefaultA() {

System.out.println("默认方法A");

methodCommon();

}

default void methodDefaultB() {

System.out.println("默认方法B");

methodCommon1();

}

private void methodCommon() {//解决默认方法重复代码

System.out.println("aaa");

System.out.println("bbb");

}

private static void methodCommon1() {

System.out.println("aaa");

System.out.println("bbb");

}

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

多态

对象的多种形态，继承是多态的实现基础。

1.引用多态

父类的引用可以指向本类的对象，Animal obj1=new Animal();

父类的引用可以指向子类的对象，Animal obj2=new Dog();

2.方法多态

创建本类对象，调用的方法为本类方法；

创建子类对象，调用的方法为子类重写的方法或者继承的方法。

如果子类有独有的方法(子类新建的方法，不与继承方法同名，非重写，父类的引用指向子类的对象时(多态情况下)，不能调用该方法)注意不能使用子类的引用指向父类对象。

在父类的引用可以指向子类的对象(多态)时使用子类特有的方法需要向下转型。

3.引用类型转换

这里说的对象类型转换，是指存在继承关系的对象，不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时，java 运行时将抛出 java.lang.ClassCastException 异常。

1.向上类型转换(隐式/自动类型转换)，是从小类型到大类型的转换

2.向下类型转换(强制类型转换)，是从大类型到小类型，这种转换有风险，可能会溢出。

3.instanceof运算符，解决引用对象的类型，避免类型转换的安全问题

在继承链中，我们将子类向父类转换称为“向上转型”，将父类向子类转换称为“向下转型”。很多时候，我们会将变量定义为父类的类型，却引用子类的对象，这个过程就是向上转型。程序运行时通过动态绑定来实现对子类方法的调用，也就是多态性。然而有些时候为了完成某些父类没有的功能，我们需要将向上转型后的子类对象再转成子类，调用子类的方法，这就是向下转型。注意：不能直接将父类的对象强制转换为子类类型，只能将向上转型后的子类对象再次转换为子类类型。也就是说，子类对象必须向上转型后，才能再向下转型。