Java面对对象知识总结

目录

 

一,关于对象

1.概念：

2.特点: 

二，面对对象的三大核心特性

1.继承                                                                                                                                                           

（1）概念：

（2）在Java中的实现形式：

（3）实现继承：

（4）继承的底层本质：

（5）若父类不带参数的解决方法：

2.封装

（1）概念：

（2）优点：

（3）实现封装：

3.多态

  (1)概念：

（2）存在条件：

（3）注意事项：

（4）使用多态：

---

 

一,关于对象 1.概念：

             所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体就是一个对象，它是一种具体的概念。

2.特点: 

              对象具有属性和行为。                                                                                                                                                                  对象具有变化的状态。                                                                                                                                                                  对象具有唯一性。                                                                                                                                                                          对象都是某个类别的实例。                                                                                                                                                            一切皆为对象，真实世界中的所有事物都可以视为对象。

二，面对对象的三大核心特性 1.继承                                                                                                                                                            （1）概念：

                    如同生活中的子女继承父母拥有的所有财产，程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。Java只支持单继承。                         

（2）在Java中的实现形式：

                   通过关键字extends实现。                                                                                                                                                              格式如下：                                                                                                                                                                                                    class 子类  extends 父类{} 

 （3）实现继承：

                     ①如果一个成员要被子类继承后使用，这个成员不能是private类型，因为私有的成员不能在类的外部使用，当然  也不能被子类使用。一般情况下，成员变量定义为protected类型，成员函数定义为public类型。                                                                     ②Java不支持多重继承，一个子类只能有一个父类。                                                                                                                   ③在Java中可以有多重继承，如A继承了B，B又继承了C。此时相当于A 间接地继承了C。

/*例如*/
package extends1;
public class Dialog{
       protected String title;
       public void show(){
              System.out.println(title+"对话框显示")；
}
}

  （4）继承的底层本质：

                        从本质上讲，子类继承父类后实例化子类对象时，系统会首先实例化父类对象。

/*例如*/
package extends2;
class Dialog{
      protected String title;
      public Dialog(){
             System.out.println("父类Dialog的构造函数")；
}
      public void show(){
             System.out.println(title+"对话框显示")；
}
}
class FontDialog extends Dialog{
      private String fontName;
      public FontDialog(String title,String fontName){
             System.out.println("子类FontDialog的构造函数")；
             this.title = title;
             this.fontName = fontName;
}
}
public class Main{
       public static void main(String[] args){
              FontDialog fd = new FontDialog("字体"，"宋体")；
}
}

                                                                                               

  （5）若父类不带参数的解决方法：

                        ①给父类增加一个不带参数的空构造函数。                                                                                                                                  ②在子类的构造函数中，第一句用super给父类构造函数参数。                                                                                   注："super(title);"必须写在子类构造函数的第一句，传入的参数必须和父类构造函数中的参数列表类型匹配。 

2.封装    （1）概念：

                         封装是将代码及其处理的数据绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部干扰且不被    误用。封装的目的在于保护信息。

   （2）优点：

                       ①保护类中的信息，它可以阻止在外部定义的代码随意访问内部代码和数据。                                                                             ②隐藏细节信息，一些不需要程序员修改和使用的信息，比如取款机中的键盘，用户只需要知道按哪个键实现  什么 *** 作就可以，至于它内部是如何运行的，用户不需要知道。                                                                                                                         ③有助于建立各个系统之间的松耦合关系，提高系统的独立性。当一个系统的实现方式发生变化时只要它的接  口不变，就不会影响其他系统的使用。                                                                                                                                                                 ④提高软件的复用率，降低成本。每个系统都是一个相对独立的整体，可以在不同的环境中得到使用。

   （3）实现封装：

                       ①将不能暴露的成员隐藏起来，例如customer类中的age，不能让其在类的外部被直接赋值。实现方法是将该    成员定义为私有的，在成员定义前加上修饰private。                                                                                                                                          ②用公共方法来暴露对该隐藏成员的访问，可以给函数加上修饰符public，将该方法定义为公共的。

class Customer{
      String name;
      String sex;
      int age;
}
public class EncText1{
      public static void main(String[] args){
             Customer zhangsan = new Customer;
             zhangsan.age = 25;
             System.out.println("zhangsan.age="+zhangsan.age);

}
}
/*修改后*/
class Customer{
      String name;
      String sex;
      private int age;
      public void setAge(int age){
             if(age<0||age>100){
                  System.out.println("age无法赋值")；
                  return;
}
             this.age = age;
}
      public int this.age;
}
public class EncText2{
      public static void main(String[] args){
             Customer zhangsan = new Customer;
             zhangsan.setAge(25);
             System.out.println("zhangsan.age="+zhangsan.getAge());

}
}

   注：①私有成员只能在定义它的类的内部被访问，在类的外部不能访问。                                                                                          ②一般情况下，可以将成员变量定义为private的通过public函数（方法）对其进行访问。例如要给一个成员赋值，可以               使用setter函数，如上面的setAge函数：要获得该变量的值， 可以使用getter函数，如上面的getAge函数。                            ③private和public都是访问区分符。

3.多态      (1)概念：

                      即同一个方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指    向对象的引用的类型有很多。

   （2）存在条件：

                      ①有继承关系。                                                                                                                                                                              ②子类重写父类的方法。                                                                                                                                                              ③父类引用指向子类对象。

    （3）注意事项：

                      ①多态是方法的多态，属性没有多态。                                                                                                                                          ②父类和子类，是要有联系的。                                                                                                                                                    ③存在条件。                                                                                                                                                                                ④父类引用指向子类对象。                                                                                                                                                            ⑤把子类转换为父类，向上转型。

/*例如*/
Dialog dialog = new FontDialog();

                      ⑥把父类转换为子类，向下转型；强制转换。

/*例如*/
Dialog dialog = new FontDialog();
FontDialog fd = (FontDialog)dialog;

                      ⑦方便方法的调用，减少重复代码。

     （4）使用多态：

                      ①函数传入的形参可以是父类类型，而实际传入的可以是子类对象。

/*例如*/
...
public class Main{
       public static void fun(Dialog dialog){
              dialog.show();
}
       public static void main(String[] args){
              fun (new FontDialog());
}
}

                      ②函数的返回类型是父类类型，而实际返回的可以是子类对象。

/*例如*/
...
public class Main{
       public static Dialog fun(){
              return new FontDialog();
}
       public static void main(String[] args){
              Dialog dialog = fun();
              dialog.show();
}
}