【设计模式】 面向对象基础

文章目录

• • 前言
  • 一、类与实例
  • 二、构造方法
  • 三、方法重载
  • 四、属性与修饰符
  • 五、封装
  • 六、继承
  • 七、多态
  • 八、重构
  • 九、抽象类
  • 十、接口

前言

本篇文章主要为大家介绍面向对象的基础知识，比如继承、多态、接口、抽象、类、集合、泛型等，以便大家可以更好的学习接下来的设计模式！

一、类与实例

对象是什么？

一切事物皆为对象，即多有的东西都是对象，对象就是可以看到、感觉到、听到、触摸到、尝到、闻到的东西，准确的说，对象是一个自包含的实体，用一组可识别的特性和行为来标识 。面向对象编程，其实就是针对对象来进行编程的意思。

至于类是什么，我们可以从一个简单的程序来切入，这个小程序最终将实现一个"动物运动会"的小例子

首先我们实现这样的一个功能，用java实现一声猫叫，并展示在控制台上即可

 public class Test{
        public static void main(String[] args) {
            System.out.println("喵");
        }
 }

现在我们需要在另一个按钮中来让小猫叫一声或者多叫几声，这里如果我们多写几个System.out.println("喵")显然同样可以达到效果，但是代码就重复了，这里我们可以通过写一个函数来解决这个问题，其他需要猫叫的地方我们只需要调用这个函数就可以了。

 public class Test{
        public static void main(String[] args) {
            System.out.println(shout());
        }
	    String shout(){
	        System.out.println("喵");
	    }
}

这里如果我们程序其他的地方也许要调用这个shout()函数，只需在shout()函数前加上修饰符public即可，这样的话，别的场合就都可以访问了。与此同时，我们发现shout()这个方法放在Test类中不是很合适，就好比居委会公用的电视放在你家，别人家没有，所以都跑来你家看电视，显然这确实不是一个办法，所以猫叫这个函数应该放在一个合适的地方，这就是"类"。类就是具有相同的属性和功能的对象的抽象的集合，我们来看代码：

 public class Cat{
       public String shout(){
           System.out.println("喵");
       }
 }

在这里"class' 是表示定义类的关键字，'Cat' 是类的名称，'shout' 就是类的方法。

这里我们有两点需要注意：

（1）、类名称首字母记着要大写。多个单词则各个首字母大写

（2）、对外公开的方法需要'public'修饰符。

那么我们要如何应用这个类呢？这里我们只需要将类实例化一下就好，其中，实例，就是实例一个真实的对象，而实例化就是创建对象的过程，使用new关键字来创建。

public class Test{
        public static void main(String[] args) {
            Cat cat = new cat();
            System.out.println(cat.shout());
        }
    }

注意这里，Cat cat = new Cat(),其实是做了两件事情。

Cat cat;      //声明一个Cat对象
cat = new Cat()  //将此cat对象实例化

Cat实例化后，等同于出生了一只小猫cat，此时就可以让小猫cat.shout()了，在任何需要小猫叫的地方都可以实例化它。

二、构造方法

接下来，我们希望出生的小猫能有有一个姓名，此时我们就需要考虑构造方法，构造方法，又叫构造函数，其实就是对类进行初始化，**构造方法与类同名，无返回值，也就不需要void，在new的时候调用。**在new Cat()中就已经调用了构造方法，虽然我们在类中并没有写过构造方法，但是，实际情况是这样的，所有的类都有构造方法，如果你不编码则系统默认生成空的构造方法，若你有定义的构造方法，那么默认的构造方法就会失效了。 也就是说java会生成一个空的构造方法Cat(),当然这个空的方法什么都不会做，只是为了让你能顺利的实例化而已。构造方法可以对类实例化，这里比如我们想为出生的小猫起一个名字，我们就应该写一个有参数的构造方法

public class Cat{
        private String name = "";
        public Cat(String name){
            this.name = name;
        }
        public String shout(){
            return "我的名字叫" + this.name + " 喵";
        }
    }

此时，我们在客户端要生成小猫是，就必须要给小猫起名字了。

 public class Test{
        public static void main(String[] args) {
            Cat cat = new Cat("咪咪");
            System.out.println(cat.shout());
        }
    }

结果显示：

我的名字叫咪咪 喵

三、方法重载

目前代码来看，如果说事先没有起好小猫的名字，这个实例就无法创造，此时如果使用Cat cat = new Cat(),会直接报'Cat方法没有采用0个参数的重载'的错误，原因就是必须要给小猫起名字，如果真的需要不起名字也要小猫创造出来，可以用"方法重载"。

方法重载提供了创建同名的多个方法的能力，但这些方法需使用不同的参数类型。

注意不光构造方法可以重载，普通方法也是可以重载的。

 public class Cat{
       private String name = "";
       public Cat(String name){
           this.name = name;
       }
       public Cat(){
           this.name = "无名";
       }
       public String shout(){
           return "我的名字叫" + this.name + " 喵";
       }
   }

这样的话写Cat cat = new Cat(),此时就不会报错了，猫叫控制台会输出 "我的名字叫无名 喵" ， 另外注意方法重载时，两个方法必须要方法名相同，但参数类型或个数必要要有所不同。 方法重载的优势是 可以在不改变原方法的基础上，新增功能。

四、属性与修饰符

属性是一个方法或一对方法，即属性适合于以字段的方式使用方法调用的场合。而字段是存储类要满足起设计所需要的数据，字段是与类相关的变量。

 public class Cat{
      //声明一个内部字段，注意是private，默认叫的次数是3
      private int shoutNum = 3;
      //表示外界可以给内部的shoutNum赋值
      public void setShoutNum(int value){
          this.shoutNum = value;
      }
      //表示外界调用时可以得到shoutNum的值
      public int getShoutNum(){
          return this.shoutNum;
      }
  }

而public与private 的区别是什么呢，它们都是修饰符，public表示他所修饰的类成员可以允许其他类来访问，俗称：公有的，而private表示只允许同一个类中的成员访问，其他类包括它的子类无法访问，俗称私有的。 如果类中的成员没有加修饰符，则被认为是private的。，属性的get和set是属性的两个方法，get返回与属性相同的数据类型，表示的意思是可以得到内部字段的引用，set作用是可以给内部字段或引用赋值。

public class Cat{
  private int shoutNum = 3;
  public int getShoutNum() {
   return shoutNum;
  }
  //去掉了set表示shoutNum这个属性是只读的
 }

public class Cat{
  private int shoutNum = 3;

  public int getShoutNum() {
   return shoutNum;
  }
  public void setShoutNum(int value){
   //控制叫声次数，最多只能叫十声
   if(value > 10){
    this.shoutNum = value;
   }else{
    this.shoutNum = 10;
   }
  }
 }

此时我们的shout方法可以改进为：

 public String shout(){
    String result = "";
     for(int i = 0;i<this.shoutNum;i++){
      result += "喵";
     }
     return "我的名字叫" + this.name + " " + reuslt;
   }

另外需要强调的是，变量私有的叫字段，公有的是属性，对于方法而言也就有私有方法与公有方法，一般不需要对外界公开的方法都应该设置其修饰符为private（私有），这样才有利于封装；

五、封装

面向对象三大特性之一'封装'。每个对象都包含它能进行操作所需要的信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己的操作。

封装有很多好处：

1.良好的封装可以减少耦合

2.类内部的实现可以自由地修改

3.类具有清晰的对外接口

与上述代码类似，如果我们现在需要增加一个狗叫的功能，就是加一个按钮'狗叫'，点击后会弹出'我的名字叫XX ，汪汪汪'，我们要怎么做呢，仿造Cat生成一份dog的即可。

Dog dog  =new Dog("旺财");
dog.setShoutNum(8);
System.out.println(dog.sjout());

六、继承

我们发现上述代码中狗和猫的代码90%以上都是重复的，在面向对象编程里，代码重复显然不是什么好事情，这里我们引入面对对象三大特性--继承。
对象的继承代表了一种'is-a'的关系，如果两个对象A和B可以描述为'B是A'，则表明B可以继承A ，上文中猫和狗都是动物，那么可以理解为，猫和狗都可以继承动物。
继承者还可以理解为是对被继承者的特殊化，因为它除了具备被继承者的特性外，还具备自己独有的特性 。比如猫可能拥有抓老鼠的特性，这不是普遍动物所具有的属性，因为在继承关系中，继承者可以完全替换成被继承者，反之则不成立。继承定义了类如何相互关联，共享特性，继承的工作方式是，定义父类和子类，或叫做基类和派生类，其中子类继承父类所有的特性，子类不但继承了父类的所有特性，还可以定义新的特性。

学习继承最好是记住三句话：

1.子类拥有父亲非pivate的属性和功能

2.子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能

3.子类还可以以自己的方式实现父类的功能（方法重写）

这里有一个新的修饰符protected表示继承时，子类可以对基类有完全访问权。

猫和狗可以同时继承父类代码如下：

  public class Animal {
        protected String name;

        public Animal(String name) {
            this.name = name;
        }

        public Animal() {
            this.name = "无名";
        }

        protected int shoutNum = 3;

        public int getShoutNum() {
            return shoutNum;
        }

        public void setShoutNum(int shoutNum) {
            this.shoutNum = shoutNum;
        }

        public String shout() {
            return "";
        }
    }

此时猫和狗代码如下：

 public class Cat extends Animal{
        public Cat(){
            super();
        }
        public Cat(String name){
            super(name);
        }
        public String shout(){
            String result = "";
            for(int i = 0;i<this.shoutNum;i++){
                result += "喵";
            }
            return "我的名字叫" + name + "" + result;
        }
    }

 public class Dog extends Animal{
        public Dog(){
            super();
        }
        public Dog(String name){
            super(name);
        }
        public String shout(){
            String result = "";
            for(int i = 0;i<this.shoutNum;i++){
                result += "汪";
            }
            return "我的名字叫" + name + "" + result;
        }
    }

客户端代码一样，但是重复的代码却大量减少了。增加动物，我们也是只需要增加对应的子类就可以了，不用继承的话，如果要使用修改功能，就必须在所有重复的方法中修改，代码越多，出错的可能性就越大，而继承的优点是，继承是的所有子类公共的部分都放在了父类，使得代码得到了共享，这就避免了重复，另外继承可使得修改或扩展继承而来的实现都较为容易。

继承也是有缺点的，那就是父类变，则子类不得不变，另外继承会破坏包装，父类实现细节暴露给子类， 这其实增大了两个类之间的耦合性。继承是一种类与类之间强耦合的关系。那么到底在什么时候用到继承呢？一般情况下，当两个类具备'is - a'的关系时，就可以考虑用继承了。 只有合理的继承才能发挥更好的作用

七、多态

下面我们介绍面向对象三大特性最后一个特性 -- 多态。
在面向对象中，多态表示不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行 。

多态中有几点需要注意：

1.子类以父类的身份出现

2.子类在工作时以自己的方式来实现

3.子类以父类的身份出现时，子类特有的属性和方法不可以使用

我们还需要了解一些概念--方法重写，子类可以选择使用override关键字，将父类实现替换为他自己的实现，这就是方法重写Override，或者叫做方法覆写。

下面我们举例：

我们知道猫和狗都有shout的方法，就是叫的声音不同，所以我们可以让Animal有一个shout的方法，然后让Cat和Dog去重写这个shout

  public class Animal {
        protected String name;

        public Animal(String name) {
            this.name = name;
        }

        public Animal() {
            this.name = "无名";
        }

        protected int shoutNum = 3;

        public int getShoutNum() {
            return shoutNum;
        }

        public void setShoutNum(int shoutNum) {
            this.shoutNum = shoutNum;
        }

        public String shout() {
            return "";
        }
    }
     public class Cat extends Animal{
        public Cat(){
            super();
        }
        public Cat(String name){
            super(name);
        }
        public String shout(){
            String result = "";
            for(int i = 0;i<this.shoutNum;i++){
                result += "喵";
            }
            return "我的名字叫" + name + "" + result;
        }
    }

 	public class Dog extends Animal{
        public Dog(){
            super();
        }
        public Dog(String name){
            super(name);
        }
        public String shout(){
            String result = "";
            for(int i = 0;i<this.shoutNum;i++){
                result += "汪";
            }
            return "我的名字叫" + name + "" + result;
        }
    }
    

客户端代码：

 public static void main(String[] args) {
        Animal[] arr = new Animal[];
        arr[0] = new Cat("小花");
        arr[1] = new Dog("旺财");
        arr[2] = new Cat("咪咪");
        arr[3] = new Dog("小黑");
        for(int i = 0;i<4;i++){
            System.out.println(arr[i].shout());
        }
    }

输出结果：

我的名字叫小花 咪咪咪

我的名字叫旺财 汪汪汪

我的名字叫咪咪 咪咪咪

我的名字叫小黑 汪汪汪

这里要注意！这个对象的声明必须是父类，而不是子类，实例化的对象是子类，这才能实现多态，多态的原理是当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就是说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。

八、重构

此时我们再引入新的动物牛，我们有一下代码

 	public class Cattle extends Animal{
        public Cattle(){
            super();
        }
        public Cattle(String name){
            super(name);
        }
        public String shout(){
            String result = "";
            for(int i = 0;i<this.shoutNum;i++){
                result += "哞";
            }
            return "我的名字叫" + name + "" + result;
        }
    }

这里发现与之前的代码除了动物叫声之外别的没有任何区别，又导致了代码重复。

这里我们可以把叫的声音部分改造为另一个方法getShoutSound()即可。

public class Animal {
        protected String name;
        public Animal(String name) {
            this.name = name;
        }
        public Animal() {
            this.name = "无名";
        }

        protected int shoutNum = 3;

        public int getShoutNum() {
            return shoutNum;
        }

        public void setShoutNum(int shoutNum) {
            this.shoutNum = shoutNum;
        }

        public String shout() {
        	String result = "";
        	for(int i = 0;i<this.shoutNum;i++){
        		result += getShoutSound() + "," //改成调用getShoutSound方法
        	}
            return "我的名字叫" + name + " " + result;
        }
        protected String getShoutSound(){
        	//将此方法给继承的类具体实现，用protected来修饰
        	return "";
        }
}
    public class Cattle extends Animal{
        public Cattle(){
            super();
        }
        public Cattle(String name){
            super(name);
        }
		public String getShoutSound(){
			return "哞";
		}
        public String shout(){
            String result = "";
            for(int i = 0;i<this.shoutNum;i++){
                result += "哞";
            }
            return "我的名字叫" + name + "" + result;
        }

此时子类就很简单了，除了叫声和构造方法不同，所有的重复都转移到了父类。

九、抽象类

我们再来观察你会发现。Animal是不可能实例化的，实例化一个动物这种说法是错误的，所以动物是一个抽象的名词，没有具体对象与之对应。所以我们可以把没有实际意义的父类改成抽象类，同样的对于Animal类的getShoutSound()方法，其实和方法体没有任何意义，所以可以将修饰符改为abstract，使之成为抽象方法，Java允许把类和方法声明为abstract，即抽象类和抽象方法。

public abstract class Animal{
	.......
	//声明一个抽象方法，在返回值类型前加abstract
	//抽象方法没有方法体，直接在括号后加"；"
	protected abstract String getShoutSound();
}

抽象类需要注意几点：

1.抽象类不能实例化

2.抽象方法是必须被子类重写的方法

3.如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否包含其他一般方法。

到底在什么时候使用抽象类呢？
抽象类通常代表一个抽象概念，他提供一个继承的出来点，当设计一个新的抽象类时，就一定是用来继承的，所以在一个以继承关系形成的等级结构里面，树叶节点应当是具体类，而树枝节点军应该是抽象类。 也就是说具体类不是用来继承的。

十、接口

接口是什么？ **接口是把隐式公共方法和属性组合起来，以封装特定功能的一个集合。一旦类实现了接口，类就可以支持接口所制定的所有属性和成员。声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的执行方式。**接口同样不能实例化，不能有构造方法和字段，不能有修饰符，比如public、private等，不能声明为虚拟的或静态的，实现接口的类就必须实现接口中的方法和属性。 一个类可以支持多个接口，多个类也可以支持相同的接口。 另外，接口中的方法或属性前面不能有修饰符、方法没有方法体。

下面我们通过实例来介绍：

public interface IChange{
	//此接口有一个方法changething
	//参数是一个字符串变量，返回字符
	public String changthing(String thing);
}

下面我们创建一个机器猫的类

 public class MachineCat extends Cat implemnets IChange{
       public MachineCat(){
           
       }
       public MachineCat(String name){
           super(name);
       }
       public String changething(String thing){
           return super.shout() + ",我有万能的口袋，我可编出 " + thing;
       }
   }

如何区分抽象类与接口呢？
从表象来说，抽象类可以给出一些成员的实现，接口却不包含成员的实现，抽象类的抽线成员可被子类部分实现，接口的成员需要实现类完全实现，一个类只能继承一个抽象类，但可以实现多个接口等。

以下三点有助于我们区分接口与抽象类：

1.类是对对象的抽象，抽象类是对类的抽象，接口是对行为的抽象。

2.如果行为跨越不同类的对象，可使用接口；对于一些相似的类对象，用继承抽象类。

3.从设计角度上讲，抽象类是从子类中发现了公共的东西，泛化出父类，然后子类继承父类，而接口是根本不知道子类的存在，方法如何实现还不确认，预先定义。抽象是自底而上抽象出来的，接口是自上而下设计出来的。

以上就是本文全部内容，接下来本专栏会持续更新设计模式相关内容。感谢各位能够看到最后，如有问题，欢迎各位大佬在评论区指正，希望大家可以有所收获！创作不易，希望大家多多支持！

最后，大家再见！祝好！我们下期见！