黑马程序员博客-------面向对象

 

  

面向过程和面向对象的不同:

面向过程思想强调的是过程（功能函数）语言 如：C语言

面向对象的思想强调的是对象（实体类）语言 如：java   C#

举例:

将肉放进冰箱这件事，如果按照面向对象的思想来思考这件事情可以分为3步：1.打开冰箱。2.存储肉 3.关上冰箱，编写程序需要将每一个动作编写成一个方法。如果按照面向对象的思想来思考这件事，冰箱和肉对应的是两个类，而打开，存储，和关闭是冰箱对应的功能（方法），如果找到冰箱这个类，就可以直接进行存取：1.冰箱打开。 2.冰箱存取 3.冰箱关闭

面向对象的特点：

1. 面向对象是人们的一种常见的思想习惯，比面向过程更符合人们的思考的习惯
2. 面向对象的出现，使很多复杂的问题变得简单

面向过程，面向对的是一个一个过程，而面向对象面对的是（冰箱）这个对象，面向过程是亲自执行这写方法过程，而面向对象是指挥对象来执行对象具有的方法，所以边的更为简单化。

封装：封装就是隐藏对象的属性

 1 class Person{
 2 //年龄属性
 3    int age;
 4  void shuohua()
 5 {
 6    System.out.println(“age=”+age);
 7 }
 8 }
 9 class Test
10 {
11    Person p=new Person();//人的对象
12    P.age=200;
13 }
14  // P.age=200不符合人类的特点

因为age可以让其他对象直接访问，所以造成了安全隐患。可以使用关键字private将属性age私有化，然后对外提供对外访问的get/set方法 如：

 1 class Person{
 2 //年龄属性
 3   private int age;
 4 public void setAge(int a)
 5 {
 6 If(a>0&&a<120)//对a进行检查，保证了数据的合法性
 7   Age=a;
 8 else
 9   System.out.println(“不合法的数据”);
10 
11 }
12 public void getAge()
13 {
14   Return age;
15 }
16 
17  void shuohua()
18 {
19    System.out.println(“age=”+age);
20 }
21 }

封装的好处：便于使用，提高安全性，提高重用性。

封装的原则：把不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共的方法对其访问。

继承：继承是面向对象编程中提供子类可以沿用父类的某些行为和特征的一种方式，继承的关键字是 extends

如：

 1 class Person{
 2    String name;
 3    int age;
 4 {
 5 class Student extends Person {
 6    Void xuexi()
 7 {
 8   System.out.println(name +“在学习”);
 9 }
10 }
11 class Test{
12    public static void main(String [] args)
13 {
14   Student s=new Student();
15     s.name=”zhangsan”;
16 s.age=20;
17 s.xuxi();//这句代码输出：zhangsan再学习 
18 }
19 }

Student类本没有name属性，因为它继承了Person类，所以它拥有了Person类的属性，Person称为父类，Student称为子类。

继承的好处：1.提高了代码的重用性。

2.让类与类之间产生了关系。

      3.给多态提供了前提 

 要注意的地方：在java语言中一个子类只允许继承一个父类，因为继承多个类会混淆类的特征和行为，使类的特征和关系不明确，违背了面向对象的编程思想。

继承具有传递性:

class Person{}

class Man extends Person {}

class Father extends Man {}

Man类可以使用Person的属性和方法，Father类可以使用Man类中的属性和方法，还可以使用Person中的属性和方法，Person类不可以使用Man中的属性和方法（一个类即可以是子类，又可以是另一个类的父类）。

所有的类都直接和间接继承了Object类

如果这个类不想被其他类继承，就可以使用final修饰，final修饰的类是最终类，final修饰的方法是最终方法，最终类不可以被继承，最终方法不可以被重写。

如果子类和父类定义了同样的属性和方法，子类调用自己的属性和方法使用this关键字，子类调用父类的同名属性和方法需要使用super关键字

多态：多态有两种表现形式，方法重载（overload）和方法重写（override）。

方法重载：是指同一个类中可以存在多个同名的方法，但这些方法的参数必须不同，程序运行时根据其参数的数量与类型调用对应的方法实现不同的功能。

例如：

1       public void plan(Apple apple)
2     {
3         System.out.println("plant:"+apple.getName);
4     }
5     public void plan(Orang orang)
6     {
7         System.out.println("plant:"+orang.getName);
8     }

自己的理解：方法的重载就是在一个类的内部具有两个或两个以上的方法名相同的方法，但是它们的参数的个数不同，方法的返回值不能作为区分重载的条件，构造方法也可以实现重载。

方法重写：是子类提供与父类相同的方法，包括方法的名称，参数列表，返回值类型。因此方法的重写提高了程序的可扩展性和可维护性,方法重载的前提是两个类必须有继承关系

 1 public class Test {//父类
 2     private String name;
 3    public String getName() {
 4         return name;
 5     }
 6     public void setName(String name) {
 7         this.name = name;
 8     }
 9 public void printInfo(Test test)//父类的方法
10    {
11        System.out.println("My name is :"+test.getName());
12    }
13 }
14 class Abc extends Test{//子类
15     private String name;
16 
17     public String getName() {
18         return name;
19     }
20 
21     public void setName(String name) {
22         this.name = name;
23     }
24     public void printInfo(Abc abc)//子类重写父类的printInfo方法
25        {
26            System.out.println("My name is :"+abc.getName());
27        }
28 }

应该注意的地方：1.方法重写应该位于子类和父类中

2.方法重写不仅要求子类于父类的方法同名，而且方法的参数类型，个数以及方法的返回值类型都要与父类一致

3.子类重写父类的方法时子类的方法访问的范围不能比父类的小。

 

转载于:https://www.cnblogs.com/CharType/p/3583496.html