java面向对象(二)-CSDN博客

本文链接：https://blog.csdn.net/w1008612315/article/details/108562824

一、封装

封装是一个面向对象的术语，其含义其实很简单，就是把东西包装起来。等下就用这种思想来解释封装性以及他带来的好处

其目的就是保护这些数据或执行过程的安全

方法本身就算是封装，封装了执行的过程，保护过程的安全，隐藏了执行细节，增强复用性
好多的方法和属性–>类也算是一个封装
私有属性，封装在类中
以后的属性不要公有（非常的不安全）

定义一个类

public class Animal {
    //将属性定义为私有的private
    private String type;
    //使用get和set对私有的属性进行封装
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
}

去使用以上定义的属性：

class Test {
    public static void main(String[] args) {
        Animal animal=new Animal();
        animal.setType("金毛");
        System.out.println(animal.getType());
    }
}

以上的程序执行的结果为：

金毛

可以看出我们将私有的属性封装起来，set方法可以对属性进行赋值，get方法可以获取到属性的值

二、继承

继承关系中一般有两个角色，父类和子类，其中父类也叫基类，子类也叫派生类。

比如我们定义一个动物类Animal，那所有的动物都可以继承自Animal、比如猫、狗等

定义一个Animal类，当做父类：

//定义了一个父类  动物类
public class Animal(){
    //定义一个变量 为动物的种类
    private String type; 
    //生成get  set
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
     public Animal() {
        System.out.println("这是动物类的构造函数");
    }
    //定义一个方法
    public void play(){
      System.out.println("动物正在开心的玩耍");
  }
}

定义一继承动物类的子类：

//定义一个子类 狗类
public class Dog extends Animal{
    private String name;
    //生成get  set
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //子类的构造函数
    public Dog(String name) {
        this.name = name;
    }
	//重写父类的方法 
    @Override
    public void play() {
        System.out.println("名字叫做"+name+"的狗正在开心的玩耍");
    }

调用

class Test {
    public static void main(String[] args)  {
        Dog dog=new Dog("旺财");
        dog.play();
    }
}

以上程序执行结果为：

这是动物类的构造函数
名字叫做旺财的狗正在开心的玩耍

特点：

一个子类的直接父类是唯一的，但是一个父类可以拥有多个子类
子类继承父类，通过一个关键字来实现 extends
子类的对象可以调用父类中（public 、protected）的属性和方法当做自己的来使用
子类可以添加自己独有的属性和方法
子类从父类中继承过来的方法不能满足子类的需要，可以在子类中重写父类的方法
每一个类都有继承类，如果不写extends关键字，默认继承Object
java中继承是单个存在的（单继承），每一个类只能有一个继承类（在extends关键字后面只能写一个类）

三、多态

同一个对象，体现出来的多种不同形态，将一种行为表现出不同的效果

想要实现多态的效果，需要先有继承关系

定义一个父类

  private String type;

    public Animal() {
        System.out.println("这是动物类的构造函数");
    }

    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }

  public void play(){
      System.out.println("动物们正在开心的玩耍");
  }

定义一个子类

 private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //构造函数
    public Dog(String name) {
        this.name = name;
    }

    @Override
    public void play() {
        System.out.println("名字叫做"+name+"的狗正在开心的玩耍");
    }

3.调用

class Test {
    public static void main(String[] args)  {
        Animal animal=new Dog("旺财");
        animal.play();
    }
}

以上程序输出结果为：

这是动物类的构造函数
名字叫做旺财的狗正在开心的玩耍

可以看出以上代码就是使用了继承，但我们在调用的时候会这样写 Animal animal=new Dog(“旺财”);

多态的特点：

父类类型的引用指向子类对象
- Animal animal=new Dog
该引用只能调用父类中定义的属性和方法
如果子类中将父类的方法重写，那么调用方法后执行的结果是子类重写之后的那个结果
如果父类与子类有同名的属性，执行父类的属性
如果父类与子类有同名的方法，执行子类重写父类的方法

四、接口

官方解释：java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这写方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为

可以理解为类抽象到极致就是接口，其实就是解决java无法使用多继承的一种手段

定义接口的语法：

interface 类名{
    抽象方法
}

实现接口的方式：

public class 类名 implements{
    实现接口的抽象方法
}

1.定义一个接口

interface joggle{
    void show();
}

2.实现接口

public class Test implements joggle{
     @Override
    public void show() {
	System.out.println("我是接口里定义的抽象方法重写");
    }
   public static void main(String[] args)  {
       Test t=new Test();
       t.show();
    }
}

以上程序执行结果为：

我是接口里定义的抽象方法重写

特点：

一个类可以实现不止一个接口
一个接口可以继承于另一个接口，或者另一些接口，接口也可以继承，并且可以多继承
一个类如果要实现某个接口的话，那么它必须实现这个接口中的所有方法
接口中的所有的方法都是抽象的和public的，所有的属性都是public、static、final的
接口用来弥补无法实现多继承的局限
接口也可以用来实现解耦