1.面向对象基础

Mr.Tong...
  • Java知识体系
  • 面向对象
  • Java知识体系
  • 面向对象
大约 11 分钟

1. 面向对象思想

面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物。面向对象是相对于面向过程来讲的,指的是把相关的数据和方法组织为一个整体来看待,从更高的层次来进行系统建模,更贴近事物的自然运行模式。

面向过程到面向对象思想层面的转变:

面向过程关注的是执行的过程,面向对象关注的是具备功能的对象。面向过程到面向对象,是程序员思想上从执行者到指挥者的转变。此概念如果直接去理解的话可能会比较抽象,因为大家缺少对原始的面向过程的开发语言的了解,下面我们举一个栗子。

我们通过生活中的一个脑筋急转弯, 来理解这个概念。

问:

​ 把大象装进冰箱 , 需要分几步?

回答:

​ 面向过程回答:

​ 3步:1把冰箱门打开, 2把大象装进去 , 3把冰箱门关闭

​ 面向对象回答:

​ 2步:1招一个能操作冰箱的工人(对象),2指挥工人装大象

思考:

​ 如果问题改成: 把100只大象依次关进冰箱,共分为几步?

​ 面向过程的回答: 此处需要省略N字。。。

​ 面向对象的回答还是2步:

​ 1招一个能操作冰箱的工人(对象) , 2指挥工人把大象依次装进去。

结论:

​ 从上述的栗子中, 我们发现面向过程很死板 ,是很难适应变化的 。 而面向对象更灵活,可复用性更高。

1. 三大思想

面向对象思想从概念上讲分为以下三种:OOAOODOOP

OOA:面向对象分析(Object Oriented Analysis)

OOD:面向对象设计(Object Oriented Design)

OOP:面向对象程序(Object Oriented Programming)

2. 三大特征

封装性:所有的内容对外部不可见

继承性:将其他的功能继承下来继续发展

多态性:方法的重载本身就是一个多态性的体现

2. 类与对象的关系

类表示一个共性的产物,是一个综合的特征,而对象,是一个个性的产物,是一个个体的特征。类必须通过对象才可以使用,对象的所有操作都在类中定义。

我们可以把类和对象的关系比作生活中的图纸与实物。

类由属性和方法组成:

  • 属性:就相当于人的一个个的特征

  • 方法:就相当于人的一个个的行为,例如:说话、吃饭、唱歌、睡觉

1. 类的定义格式

class 类名称{
	成员属性
	成员方法
}

2. 属性与方法

属性定义格式:
	数据类型 属性名;
属性定义并赋值的格式:
	数据类型 属性名 = 初始化值;
方法定义格式:
	权限修饰符 返回值类型 方法名(形式参数列表) {
		//方法体
		return 返回值;
	}

3. 对象的创建与使用

一个类要想真正的进行操作,则必须依靠对象,对象的定义格式如下:

类名称 对象名称 = new 类名称() ;

如果要想访问类中的属性或方法(方法的定义),则可以依靠以下的语法形式:

访问类中的属性: 对象.属性 ;

调用类中的方法: 对象.方法(实际参数列表) ;

3. 构造方法(构造器)

回顾对象创建,在右侧Person后面出现的小括号, 其实就是在调用构造方法 !

Person p = new Person();

作用用于对象初始化,在创建对象时,自动调用。所有的Java类中都会至少存在一个构造方法,如果一个类中没有明确的编写构造方法,则编译器会自动生成一个无参的构造方法,构造方法中没有任何的代码!如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。

定义格式

与普通方法基本相同, 区别在于: 方法名称必须与类名相同, 没有返回值类型的声明 !

class Person{
	//构造方法    
	public Person(){
		System.out.println("对象创建时,此方法调用");
	}
}

构造方法设计过程中,建议自定义无参构造方法,不要对编译器形成依赖,避免错误发生。

  • 当类中有非常量成员变量时,建议提供两个版本的构造方法,一个是无参构造方法,一个是全属性做参数的构造方法。

  • 当类中所有成员变量都是常量或者没有成员变量时,建议不提供任何版本的构造。如上也是构造方法的重载,

4. 重载、重写

1. 重写(Override)

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

  • 重写中子类可以根据需要,定义特定于自己的行为。
  • 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

例如: 父类的一个方法申明了一个检查异常 IOException,但是在重写这个方法的时候不能抛出 Exception 异常,因为 ExceptionIOException 的父类,抛出 IOException 异常或者 IOException 的子类异常。

在面向对象原则里,重写意味着可以重写任何现有方法。实例如下:

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

以上实例编译运行结果如下:

动物可以移动
狗可以跑和走

在上面的例子中可以看到,尽管 b 属于 Animal 类型,但是它运行的是 Dog 类的 move方法。这是由于在编译阶段,只是检查参数的引用类型。然而在运行时,Java 虚拟机(JVM)指定对象的类型并且运行该对象的方法。

因此在上面的例子中,之所以能编译成功,是因为 Animal 类中存在 move 方法,然而运行时,运行的是特定对象的方法。

思考以下例子:

lass Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

以上实例编译运行结果如下:

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

该程序将抛出一个编译错误,因为b的引用类型Animal没有bark方法。

方法的重写规则

  • 参数列表与被重写方法的参数列表必须完全相同。
  • 返回类型与被重写方法的返回类型可以不相同,但是必须是父类返回值的派生类(java5 及更早版本返回类型要一样,java7 及更高版本可以不同)。
  • 访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为 public,那么在子类中重写该方法就不能声明为 protected。
  • 父类的成员方法只能被它的子类重写。
  • 声明为 final 的方法不能被重写。
  • 声明为 static 的方法不能被重写,但是能够被再次声明。
  • 子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为 private 和 final 的方法。
  • 子类和父类不在同一个包中,那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
  • 重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以。
  • 构造方法不能被重写。
  • 如果不能继承一个类,则不能重写该类的方法。

Super 关键字的使用

当需要在子类中调用父类的被重写方法时,要使用 super 关键字

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法
 
   }
}

以上实例编译运行结果如下:

动物可以移动
狗可以跑和走

2. 重载(Overload)

重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。

每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

重载规则:

  • 被重载的方法必须改变参数列表(参数个数或类型不一样);
  • 被重载的方法可以改变返回类型;
  • 被重载的方法可以改变访问修饰符;
  • 被重载的方法可以声明新的或更广的检查异常;
  • 方法能够在同一个类中或者在一个子类中被重载。
  • 无法以返回值类型作为重载函数的区分标准。
public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

3. 重写与重载之间的区别

区别点重载方法重写方法
参数列表必须修改一定不能修改
返回类型可以修改一定不能修改
异常可以修改可以减少或删除,一定不能抛出新的或者更广的异常
访问可以修改一定不能做更严格的限制(可以降低限制)

4. 构造方法能不能重写?

构造方法能重载但不能重写。因为构造方法需要和类保持同名,而重写的要求是子类方法要和父类方法保持同名。如果允许重写构造方法的话,那么子类中将会存在与类名不同的构造方法,这与构造方法的要求是矛盾的。

5. 总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载可以理解成多态的具体表现形式。

  • (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
  • (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
  • (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

img

img

5. 匿名对象

没有对象名称的对象 就是匿名对象。

匿名对象只能使用一次,因为没有任何的对象引用,所以将称为垃圾,等待被G·C回收。

只使用一次的对象可以通过匿名对象的方式完成,这一点在以后的开发中将经常使用到。

你认为这篇文章怎么样?

  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
评论
  • 按正序
  • 按倒序
  • 按热度
Powered by Waline v2.14.1