zoukankan      html  css  js  c++  java

  • 面向对象

    1.什么是对象

      简单的说，对象就是对客观世界中实体的映射，对象划分为三个部分，分别是标识、静态部分和动态部分：

    • 标识：区分对象的标示符；（例如学生）
    • 静态部分：就是指对象本身的属性；（例如学生的：姓名、性别、年龄、成绩等）
    • 动态部分：是指对象的动作；（例如学生：跳舞、唱歌等）

      *需要注意的是，尽管可以将现实世界当中的一切事物都当做对象来看，但是我们用来操作的并不是对象本身，而是对象的引用。

      *对象及其引用是相对独立的，一个引用的存在并不代表着一定有一个对象已经与其建立了连接关系。例如 int[] a; 这只是一个引用。正确的用法是在声明一个引用的同时对其初始化。例如int [] =new int[4];

      *创建的引用通常是使用关键字new来与其对象进行连接的。

    2.什么是类，类和对象的关系

      类是对同一类事物的统称，是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。

    [修饰符] class 类名 [extends 父类名] [implements 接口名] {

                        成员变量声明；
                        成员函数声明；

                    }

      类和对象的关系：类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类

    型的对象中的方法和变量的软件模板。也就是说，类是对象的抽象和归纳，对象是类的实例。

       实例1.1：

     1 /*类的定义*/
 2 class Person {    //声明的类类型Person
 3     public String name;  //姓名属性
 4     public int  age;     //年龄属性
 5     public Person()   //类的构造方法
 6     {
 7         System.out.println("个人资料");
 8         name="zhang";   //为创建的对象初始化
 9         age=17;
10         System.out.println("姓名是："+name);  
11         System.out.println("年龄是："+age);
12     }
13 }
    1 /*测试类*/
2 public class Text {  
3 
4     public static void main(String[] args) {
5         
6         Person students=new Person();  //对象，是类Person的实例
7     }
8 
9 }

      *在测试‘类中需要注意的是：声明的引用在这里没有初始化，这是因为在Person类中创建了构造函数，在构造函数中已经对创建的对象 students 对象进行了初始化。

    运行测试类结果是：

    

    

    3.面向对象的特性
    

      面向对象主要有三大特性：封装、继承和多态。
    

      封装性：它是面向对象编程的核心思想，其实指的就是将描述某种实体的数据和基于这些数据的操作集合到一起，形成了一个封装体。以类的形式出现）
    

        面向对象思想中的封装性优点有以下几个：
    

      

    1. 便于编程人员方便快捷地、正确地理解和使用，有效地避免了编程人员因修改类的属性而引发的错误；
      2. 

    2. 更加清晰的体现了程序之间的松散耦合关系，提高了应用程序中功能模块的独立性；
      3. 

    3. 提高了软件代码的可重用性；
      4. 

    4. 降低了大型应用程序构建时的风险。
      5. 

    

          *封装性是通过访问控制修饰符来限定应用程序内部文件的访问级别，java语言中的访问控制级别有4种：public、protected、private、default.
    

      

    1.  public       共有的，公共的，访问级别最高，被访问时不受任何限制；
      2. 

    2.  protected     受保护的，只能由派生类或统一程序包中的类进行访问，对其他包的派生类而言，效果相当于共有的（public），对于其他程序的非派生类来说，其效果相当于私有的（private）；
      3. 

    3.  private     私有的，访问级别最低，不允许除了它本身所在的类之外的类对其进行访问；
      4. 

    4.  default      默认的，指的是不加任何访问控制修饰符，只能由同一程序包中的类进行访问，对其所在包中的其他类而言，效果相当于共有的（public），对于应用程序的其他程序包中的类来说，其效果相当于私有的（private）；
      5. 

    

    封装性见实例1.2  
    

    

     1 /*Output.java*/
 2 public class Output {  // 声明类
 3     public int a=10;   //属性的封装
 4     private int b=3;
 5     protected double c=7.3d; 
 6     public int geta(){    //声明方法返回a的值  方法的封装
 7         System.out.println(a);
 8         return a;
 9     }
10     public void output(String str) {  //声明方法返回一句话  方法的封装
11         System.out.println(str);
12 
13     }
14 
15 }
    

    

        测试类：
    

    

     1 /*Text2.java*/
 2 public class Text2 {
 3 
 4     public static void main(String[] args) {
 5         
 6         String str ="这是封装的实例";
 7         Output out = new Output();  //创建对象
 8         out.geta();  //  调用geta()方法 
 9         out.output(str);  //调用output(str)方法
10     }
11 
12 }
    

    

      运行结果:
    

    

      继承性：继承反映的是两个类之间的关系。在面向对象程序设计中，根据已有的类派生出新类的这种现象，我们称之为继承机制。当一个类具有另一个类的所有属性和方法的时
    

    候，我们称前者继承了后者，这两个类具有继承关系。被继承的类我们称之为基类或父类，而继承父类所有属性和方法的类称之为子类或派生类。继承是通过关键字extends来实现
    

    的。如例1.3
    

        例1.3  类参考例1.1
    

    

     1 class Student extends Person{  //子类Student继承Person类
 2     
 3     public  Student(){   //定义构造函数
 4         String name = "xiaopeng";   //对Person类中的name进行了重写
 5         System.out.println("学生的个人资料");
 6         System.out.println("学生姓名"+name); // 输出的结果是重写后的name
 7         System.out.println("学生的年龄"+this.age);
 8         
 9     }    
10 }
    

    

    

     1 public class Text1 {  //测试类
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         Person students=new Person();
 6         System.out.println("         ");
 7         Student sdt=new Student();  //创建对象sdt,是子类Student的实例化
 8      
 9     }
10 
11 }
    

    

    运行结果是：sfsfaf
    

    

      多态性：相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。子类以父类的身份出现，但做事情时还是以自己的方法实现。子类以父类的身份出现需要向上
    

    转型(upcast)，其中向上转型是由JVM自动实现的，是安全的，但向下转型(downcast)是不安全的，需要强制转换。子类以父类的身份出现时自己特有的属性和方法将不能使用。
    

       在java语言中，多态体现在以下几个方面：
    

      

    1. 方法重载
      2. 

    2. 方法重写
      3. 

    3. 抽象类
      4. 

    4. 接口
      5. 

    

      
    


    

    
    来自张晓鹏的博文

    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  jQuery中常用方法和jQuery思维导图
                    
    jQuery
                    
    JS-AJAX and jQuery-AJAX
                    
    Linux系统里导入maven项目
                    
    maven项目里的ssh框架整合
                    
    spring框架的两大核心：IOC和AOP
                    
    JAVA的抽象类和接口
                    
    JAVA面向对象的三大特征
                    
    JAVA---面向对象
                    
    JAVA---方法
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/zhangxiaopeng/p/4782446.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看