Java面向对象总结篇

Java面向对象总结

小白今天来整理一下Java面向对象,顺带回顾一下Java基础,虽然小白也没啥基础,但是还是写一点吧,毕竟发布一篇原创博客还有10个积分/xieyanxiao

什么是面向对象?

面向对象在百度百科中是这样解释的:“面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物”。说的好像很流弊的样子,看看就行。

说道面向对象,大家肯定会想到面向对象的三大基本特征:封装、继承、多态
在这里插入图片描述
下面小白就从这三大基本特征来说一下Java的面向对象。

Java 封装

在面向对象设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
① 封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据,必须通过严格的接口控制。
② 封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
封装的优点:
1、封装能够减少耦合性
2、类内部的结构可以自由修改
3、可以对成员变量进行控制
4、隐藏信息,实现细节
下面小白举个例子来实现一下封装的步骤吧:
在这里插入图片描述
如上图所示:将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

Java 继承

继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,下面我们通过一个例子来说一下继承的优点吧,如下:
在这里插入图片描述
在这里插入图片描述
从这两段代码可以看出来,代码存在重复了,导致后果就是代码量大且臃肿,而且维护性不高,所以要从根本上解决这两段代码的问题,就需要继承,将两段代码中相同的部分提取出来组成 一个父类,如下:
在这里插入图片描述
这个Animal类就可以作为一个父类,然后猪类和狗类继承这个类之后,就具有父类当中的属性和方法,子类就不会存在重复的代码,维护性也提高,代码也更加简洁,提高代码的复用性(复用性主要是可以多次使用,不用再多次写同样的代码) 继承之后的代码:
在这里插入图片描述
在这里插入图片描述
需要注意的是 Java 不支持多继承,但支持多重继承
什么意思呢,小白简单来解释一下,
public class A {

}
public class B extends A{

} //这是单继承

public class A {

}
public class B extends A{

}
public class C extends B{

}//这是多重继承

public class A {

}
public class B extends A{

}
public class C extends A{

}//这是不同的类继承同一个类
下面这种写法是不正确
public class A {

}
public class B {

}
public class C extends A,B{

}//JAVA不支持多继承

继承的特性

1、子类拥有父类非 private 的属性、方法
2、子类可以拥有自己的属性和方法,即子类可以对父类进行扩展
3、子类可以用自己的方式实现父类的方法
4、提高了类之间的耦合性

继承的缺点

耦合度高就会造成代码之间的联系越紧密,代码独立性越差

Java多态

多态是同一个行为具有多个不同表现形式或形态的能力。同一个接口,使用不同的实例而执行不
同操作。例如:
一台打印机,他有打印功能,但是打印的具体内容不同,彩色打印机打印的效果是彩色的,黑白打印机打印的是黑白的。

多态的优点

1、消除类型之间的耦合关系
2、可替换性
3、可扩充性
4、接口性
5、灵活性
6、简化性

多态的三个必要条件

继承、重写、父类引用指向子类对象,例如:
Animal dog = new Dog();
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
以下是一个多态实例的演示,详细说明请看注释:

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

输出结果为:
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

下面顺带说总结一下抽象类和接口

java 抽象类

什么是抽象类抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样
由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用
举个例子,下面给大家简单的介绍一下抽象类:

public abstract class Students
{
   private String name;
   private String address;
   public Employee(String name, String address)
   {
      System.out.println("构造方法");
      this.name = name;
      this.address = address;
   }
   public void speak()
   {
      System.out.println("我叫 " + this.name
       + "家住" + this.address);
   }
   public String toString()
   {
      return name + " " + address;
   }
   public String getName()
   {
      return name;
   }
      public void settName(String newName)
   {
      name = newName;
   }
   public String getAddress()
   {
      return address;
   }
   public void setAddress(String newAddress)
   {
      address = newAddress;
   }
}
//大家应该注意到了,抽象类除了类前面的修饰符不一样,其他的和普通类没啥区别。 
 在Java语言中使用abstract class来定义抽象类
 
public class Test
{
   public static void main(String [] args)
   {
      /* 以下是不允许的,会引发错误 */
      Students e = new Students("张三", "召唤师峡谷");
      System.out.println("**************");
      e.speak();
    }
}
//这样写法是不正确的,当你编译Test类的时候,程序会报错
Students is abstract; cannot be instantiated....

所以,抽象类不能实例化对象,但是我们可以继承抽象类。如下:

public class Person extends Students
{
   private int age; 
   public Person (String name, String address, int age)
   {
       super(name, address);
       setAge(age);
   }
   public void speak()
   {
        System.out.println("我叫" + this.name + "家住" + this.address+ "年龄" +this.age);
   }
    public int getAge()
    {
      return age;
    }
    public void setAge(int age)
    {
       if(age>0)
       {
          age= age;
       }
     }
}

//虽然我们不能实例化Students类,但是我们可以实例化Person类,
public class Test
{
   public static void main(String [] args)
   {
      Person p = new Person ("张三", "召唤师峡谷蓝方", 23);
      Students s = new Person ("李四", "召唤师峡谷红方", 24);
      p.speak();
      s.speak();
    }
}
输出结果为:
我叫张三家住召唤师峡谷蓝方年龄23
我叫李四家住召唤师峡谷红方年龄24

抽象方法

如果你想设计这样一个类,该类包含一个特别的成员方法,该方法的具体实现由它的子类确定,那么你可以在父类中声明该方法为抽象方法。
Abstract 关键字同样可以用来声明抽象方法,抽象方法只包含一个方法名,而没有方法体。
抽象方法没有定义,方法名后面直接跟一个分号,而不是花括号。例如:

public abstract class TestStudents
{
   private String name;
   private String address;
   private int age;
   
   public abstract String play();//抽象方法
}

//声明抽象方法会造成以下两个结果:
1、如果一个类包含抽象方法,那么该类必须是抽象类。
2、任何子类必须重写父类的抽象方法,或者声明自身为抽象类。
另外还有一点需要注意一下:抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类

Java 接口 (特殊的抽象类)

接口定义:接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。

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

接口与类的相似点

1、一个接口可以有多个方法
2、接口文件保存在 .java 结尾的文件中,文件名使用接口名。
……

接口与类的区别

1、接口不能用于实例化对
2、接口没有构造方法
3、接口中所有的方法必须是抽象方法
4、接口不能包含成员变量,除了 static 和 final 变量
5、接口不是被类继承了,而是要被类实现
6、接口支持多继承

接口的特性:

1、接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
2、接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
3、接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

1、 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
2、抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
3.、接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
4、 一个类只能继承一个抽象类,而一个类却可以实现多个接口。
下面我们来定义一个接口看一下:

interface Animal {
   public void eat();
   public void paly();
}

接口的实现

类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。
例如:

public class Dog implements Animal{
 
   public void eat(){
      System.out.println("dog eats");
   }
 
   public void paly(){
      System.out.println("dog play");
   } 
   public static void main(String args[]){
      Dog d = new Dog();
      d.eat();
      d.play();
   }
}

以上就是小白整理的关于Java面向对象方面的知识点,就简单的整理了一下,其中还有或多或少有不足之处,还望看到的大佬们指点一下/tuosai


业精于勤,荒于嬉---------自带小尾巴

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读