AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

[零基础学JAVA]Java SE面向对象部分-11.面向对象基础（06）

2017-11-08 821
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
上季内容回顾：
题目的分析和类图的设计
本季主要知识点：
本季要点：内部类的定义、使用和外部调用。
本季重点讲解了JAVA中的内部类和对象数组的使用，以及对上季中的习题进一步引申。
image
上季内容遗留下来这么一道题目，我们来分析一下哈~
class Employee    
{ 
   private String empno ; 
   private String empname ; 
   private  float salary ; 
   private  float inc ; 

   //构造方法 
   public Employee(){} 
   public Employee(String empno,String empname, float salary, float inc){ 
     this.setEmpno(empno); 
     this.setEmpname(empname); 
     this.setSalary(salary); 
     this.setInc(inc); 
  } 

   //setter和getter 
   public  void setEmpno(String empno){ 
          this.empno = empno ; 
  } 
   public  void setEmpname(String empname){ 
          this.empname = empname ; 
  } 
   public  void setSalary( float salary){ 
          this.salary = salary ; 
  } 
   public  void setInc( float inc){ 
          this.inc = inc ; 
  } 
   public String getEmpno(){ 
          return  this.empno ; 
  } 
   public String getEmpname(){ 
          return  this.empname ; 
  } 
   public  float getSalary(){ 
          return  this.salary ; 
  } 
   public  float getInc(){ 
          return  this.inc ; 
  } 
    
   //计算增长后的工资总额 
   public  float calSalary(){ 
     return  this.salary+ this.salary* this.inc; 
  } 
} 
public  class Demo01 
{ 
   public  static  void main(String args[]){ 
    Employee e =  new Employee( "e001", "王乾",5000.0f,0.1f); 
    System.out.println(e.calSalary()); 
  } 
} 
测试下哈~
image
image
class Math 
{ 
   private  float x; 
   private  float y; 

   public Math(){} 
   public Math( float x, float y){ 
     this.setX(x); 
     this.setY(y); 
  } 

   //求和 
   public  float sum(){ 
     return  this.x +  this.y; 
  } 
   //求差 
   public  float sub(){ 
     return  this.x -  this.y; 
  } 
   //求平均值 
   public  float avg(){ 
     return  this.sum() / 2; 
  } 
   //求最大值 
   public  float max(){ 
     return  this.x> this.y? this.x: this.y; 
  } 
   //求最小值 
   public  float min(){ 
     return  this.x< this.y? this.x: this.y; 
  } 

   public  void setX( float x){ 
     this.x = x; 
  } 
   public  void setY( float y){ 
     this.y = y; 
  } 
   public  float getx(){ 
     return  this.x; 
  } 
   public  float gety(){ 
     return  this.y; 
  } 
} 
public  class Demo02 
{ 
   public  static  void main(String args[]){ 
  Math m =  new Math(50.0f,60.0f); 
  System.out.println( "求和："+m.sum()); 
  System.out.println( "求差："+m.sub()); 
  System.out.println( "平均值："+m.avg()); 
  System.out.println( "最大值："+m.max()); 
  System.out.println( "最小值："+m.min()); 
  } 
}
我们验证下计算结果对不对哈~
image
内部类
image
本次专题中JAVA SE 课程已经融合了JAVA EE的设计思路
在一个类的内部还有另外一个类 
class Outer{    
        定义了若干个属性    
        定义了若干个方法    
         class Inner{    
         // 内部类    
        }    
} 
内部类定义后有什么好处呢？我们来看Demo03哈~
//外部类 
class Outer 
{ 
   private String name =  "redking.blog.51cto.com" ; 
   //内部类 
   class Inner 
  { 
     //此方法用于打印Outer类中的name属性 
     public  void printName(){ 
      System.out.println( "name = "+name) ; 
    } 
  } 
   //定义一个外部类的方法 
   public  void fun(){ 
     //产生内部类的实例化对象，同时调用里面的方法 
     new Inner().printName() ; 
  } 
} 
public  class Demo03 
{ 
   public  static  void main(String args[]){ 
   //产生了外部类的对象 
  Outer out =  new Outer() ; 
   //调用fun()方法之后打印输出 
  out.fun() ; 
  } 
}
验证下效果
image
编译*.java文件之后，可以发现产生了两个文件： 
· Outer$Inner.class ： Outer.Inner，如果要想找到Inner类，则必须先找到Outer 
· Outer.class ：外部类的class文件。
能否发现内部类有哪些好处呢？ 
现在将内部类拿到外部类之外，要求；最后可以实现同样的程序,我们来看Demo04哈~
//外部类 
class Outer 
{ 
   private String name =  "redking.blog.51cto.com" ; 
   //定义一个外部类的方法 
   public  void fun(){ 
     //产生内部类的实例化对象，同时调用里面的方法 
     new Inner( this).printName() ; 
  } 
   //必须使用setter和getter方法 
   public  void setName(String name){ 
     this.name = name ; 
  } 
   public String getName(){ 
     return  this.name ; 
  } 
} 
//现在我们把内部类拿到外部，这样就形成了两个类哈~ 
//内部类 
class Inner 
{ 
   //必须想办法为out对象实例化 
   private Outer out =  null ; 
   public Inner(Outer out){ 
     this.out = out ; 
  } 
   //此方法用于打印Outer类中的name属性 
   public  void printName(){ 
     //此处如果要访问name属性，则肯定必须通过Outer类的对象来完成 
    System.out.println( "name = "+out.getName()) ; 
  } 
} 
public  class Demo04 
{ 
   public  static  void main(String args[]){ 
   //产生了外部类的对象 
  Outer out =  new Outer() ; 
   //调用fun()方法之后打印输出 
  out.fun() ; 
  } 
}
修改完后我们看下效果
image
以上程序多了很多内容： 
1、 Outer.class类中多了setter和getter方法，同时在fun方法中还必须传入当前操作Outer类的对象，因为Inner类中必须使用此对象才可以访问Outer类中的属性。 
2、 Inner.class 类中多了一个构造方法，用于接收Outer 类的实例化对象，同时必须使用对象.方法()的形式才可以找到name的值并输出。
综合以上几点，发现内部类的优缺点 
· 内部类访问外部类的私有属性很方便 
· 内部类在使用时代码的结构是不好的
下面我们还是看Demo03，在此基础上我们不想使用fun()方法调用printName()方法，希望直接在主方法中调用，我们看下面。
//外部类 
class Outer 
{ 
   private String name =  "redking.blog.51cto.com" ; 
   //内部类 
   class Inner 
  { 
     //此方法用于打印Outer类中的name属性 
     public  void printName(){ 
      System.out.println( "name = "+name) ; 
    } 
  } 
} 
public  class Demo05 
{ 
   public  static  void main(String args[]){ 
   //产生了外部类的对象 
  Outer out =  new Outer() ; 
   //能否直接在Main方法中直接产生Inner类的实例化对象 
   //调用printName方法呢？我们验证一下哈~~~ 
   //声明内部类对象：外部类.内部类 内部类对象 = null ; 
   //实例化内部类对象：内部类对象 = new 外部类实例.new 内部类() : 
   Outer.Inner in = out.new Inner() ; 
   in.printName() ; 
  } 
}
测试下，可以哈，这是这样代码就更加别扭了哈~
image
此外，也可以在一个方法中定义内部类。
class Outer 
{ 
   private String name =  "redking.blog.51cto.com" ; 
   public  void fun(){ 
     //在方法中定义内部类 
     class Inner 
    { 
       public  void print(){ 
        System.out.println( "name = "+name); 
      } 
    } 
     new Inner().print(); 
  } 
} 
public  class Demo06 
{ 
   public  static  void main(String args[]){ 
     new Outer().fun(); 
  } 
}
验证下
image
注意点： 
在方法中定义的内部类，可以访问外部类的任何属性，但是不能直接访问方法中的参数或变量。
这么理解呢？我们来看下Demo07哈~
class Outer 
{ 
   private String name =  "redking.blog.51cto.com" ; 
   public  void fun( int i){ 
     int j = 10 ; 
     //在方法中定义内部类 
     class Inner 
    { 
       public  void print(){ 
        System.out.println( "name = "+name); 
        System.out.println( "i+j = "+(i+j)); 
      } 
    } 
     new Inner().print(); 
  } 
} 
public  class Demo07 
{ 
   public  static  void main(String args[]){ 
     new Outer().fun(20); 
  } 
}
就像这样哈：
image
如果想在内部类中访问方法中的参数，则参数前必须加上一个“final”关键字。
class Outer 
{ 
   private String name =  "redking.blog.51cto.com" ; 
   public  void fun( final  int i){ 
     final  int j = 10 ; 
     //在方法中定义内部类 
     class Inner 
    { 
       public  void print(){ 
        System.out.println( "name = "+name); 
        System.out.println( "i+j = "+(i+j)); 
      } 
    } 
     new Inner().print(); 
  } 
} 
public  class Demo08 
{ 
   public  static  void main(String args[]){ 
     new Outer().fun(20); 
  } 
}
现在程序就执行了
image
对象数组： 
· 数组：是一组相同类型变量的集合 
· 对象数组：就是一组对象。
对象数组的定义格式： 
声明对象数组：类名称 [] 对象数组名称 = null ; 
为对象数组开辟空间：对象数组名称 = new 类名称[个数] ;
注意： 
数组中使用new开辟空间之后，所有的数据都是默认值，对象的默认值就是null。
class Person 
{ 
   private String name ; 
   private  int age ; 
   public Person(String name, int age){ 
     this.name = name ; 
     this.age = age ; 
  } 
   //所有的信息不能直接在类中输出，必须返回 
   public String getInfo(){ 
     return  "姓名："+ this.name+ "，年龄："+ this.age; 
  } 
}; 
public  class Demo09 
{ 
   public  static  void main(String arg[]){ 
     //声明一个Person类的对象数组 
    Person p[] =  null ; 
     //为对象数组开辟空间 
    p =  new Person[10] ; 
     //开辟空间之后所有的内容都是默认值，引用的为null 
     for ( int i=0;i<p.length ;i++ ) 
    { 
      System.out.println(p[i]); 
    } 
  } 
};
我们看下效果，现在所有的对象的默认值都是null
image
现在我们分别为对象数组中的每个元素实例化
class Person 
{ 
   private String name ; 
   private  int age ; 
   public Person(String name, int age){ 
     this.name = name ; 
     this.age = age ; 
  } 
   //所有的信息不能直接在类中输出，必须返回 
   public String getInfo(){ 
     return  "姓名："+ this.name+ "，年龄："+ this.age; 
  } 
}; 
public  class Demo10 
{ 
   public  static  void main(String arg[]){ 
     //声明一个Person类的对象数组 
    Person p[] =  null ; 
     //为对象数组开辟空间 
    p =  new Person[10] ; 
     //因为使用的是动态初始化 
     //所以此处必须依次为其实例化，对象数组中的每一个元素都是null 
     for ( int i=0;i<p.length ;i++ ) 
    { 
       //分别为对象数组中的每个元素实例化 
      p[i] =  new Person( "michael"+i,20+i); 
    } 
     //开辟空间之后所有的内容都是默认值，引用的为null 
     for ( int i=0;i<p.length ;i++ ) 
    { 
      System.out.println(p[i]); 
    } 
  } 
};
我们看下对象数组中有没内容了
image
对象数组中每个元素都有内容了，下面我们就来取出内容哈~
class Person 
{ 
   private String name ; 
   private  int age ; 
   public Person(String name, int age){ 
     this.name = name ; 
     this.age = age ; 
  } 
   //所有的信息不能直接在类中输出，必须返回 
   public String getInfo(){ 
     return  "姓名："+ this.name+ "，年龄："+ this.age; 
  } 
}; 
public  class Demo11 
{ 
   public  static  void main(String arg[]){ 
     //声明一个Person类的对象数组 
    Person p[] =  null ; 
     //为对象数组开辟空间 
    p =  new Person[10] ; 
     //因为使用的是动态初始化 
     //所以此处必须依次为其实例化，对象数组中的每一个元素都是null 
     for ( int i=0;i<p.length ;i++ ) 
    { 
       //分别为对象数组中的每个元素实例化 
      p[i] =  new Person( "michael"+i,20+i); 
    } 
     //开辟空间之后所有的内容都是默认值，引用的为null 
     for ( int i=0;i<p.length ;i++ ) 
    { 
      System.out.println(p[i].getInfo()); 
    } 
  } 
};
验证下
image
这就叫对象数组哈~
对象数组也可以采用静态初始化方式：
class Person 
{ 
   private String name ; 
   private  int age ; 
   public Person(String name, int age){ 
     this.name = name ; 
     this.age = age ; 
  } 
   //所有的信息不能直接在类中输出，必须返回 
   public String getInfo(){ 
     return  "姓名："+ this.name+ "，年龄："+ this.age; 
  } 
}; 
public  class Demo12 
{ 
   public  static  void main(String arg[]){ 
     //声明一个Person类的对象数组 
    Person p[] = { new Person( "michael",30), new Person( "amy",31), new Person( "joy",32)} ; 
     //开辟空间之后所有的内容都是默认值，引用的为null 
     for ( int i=0;i<p.length ;i++ ) 
    { 
      System.out.println(p[i].getInfo()); 
    } 
  } 
};
看下效果哈~
image
思考题： 
建立一个Student 类，里面包含name、age、score 属性，现在要求生成十个Student 对象，之后对这些对象进行排序，按成绩由高到低排序，如果成绩相等，则按年龄由高到低排序。

总结 
1、内部类的使用 
· 内部类的优点与缺点 
2、对象数组，是一组对象，必须分别实例化 
3、思考题非常重要哈~~~（留到面向对象结束后分析哈）
###############################################################






本文转自redking51CTO博客，原文链接： http://blog.51cto.com/redking/124073 ，如需转载请自行联系原作者
文章标签：
Java
关键词：
Java面向对象
Java se
Java se面向对象
Java基础
Java se面向对象基础
技术小美
目录
相关文章
啦啦啦191
|
3月前
|
Java
Java基础语法与面向对象
重载（Overload）指同一类中方法名相同、参数列表不同，与返回值无关；重写（Override）指子类重新实现父类方法，方法名和参数列表必须相同，返回类型兼容。重载发生在同类，重写发生在继承关系中。
啦啦啦191
154 1
啦啦啦191
|
3月前
|
存储 Java 关系型数据库
Java 项目实战基于面向对象思想的汽车租赁系统开发实例 汽车租赁系统 Java 面向对象项目实战
本文介绍基于Java面向对象编程的汽车租赁系统技术方案与应用实例，涵盖系统功能需求分析、类设计、数据库设计及具体代码实现，帮助开发者掌握Java在实际项目中的应用。
啦啦啦191
131 0
34789737
|
3月前
|
安全 Java API
Java SE 与 Java EE 区别解析及应用场景对比
在Java编程世界中，Java SE（Java Standard Edition）和Java EE（Java Enterprise Edition）是两个重要的平台版本，它们各自有着独特的定位和应用场景。理解它们之间的差异，对于开发者选择合适的技术栈进行项目开发至关重要。
34789737
420 1
艾伦~耶格尔
|
4月前
|
安全 Java 编译器
Java面向对象
本文深入讲解了Java面向对象编程（OOP）的四大特性：封装、继承、多态与抽象，以及方法的设计与使用。通过示例展示了如何用类和对象组织代码，提升程序的可维护性与扩展性。
艾伦~耶格尔
223 0
潘安的酱油
|
5月前
|
存储 Java 测试技术
Java基础 - 面向对象
面向对象编程是Java的核心，包含封装、继承、多态三大特性。封装隐藏实现细节，提升代码可维护性与安全性；继承实现类间IS-A关系，支持代码复用；多态通过继承、重写与向上转型，实现运行时方法动态绑定，提升系统扩展性与灵活性。
潘安的酱油
97 0
34789737
|
6月前
|
设计模式 算法 Java
Java SE 与 Java EE 组件封装使用方法及实践指南
本指南详细介绍了Java SE与Java EE的核心技术使用方法及组件封装策略。涵盖集合框架、文件操作、Servlet、JPA、EJB和RESTful API的使用示例，提供通用工具类与基础组件封装建议，如集合工具类、文件工具类、基础Servlet、实体基类和服务基类等。同时，通过分层架构集成示例展示Servlet、EJB和JPA的协同工作，并总结组件封装的最佳实践，包括单一职责原则、接口抽象、依赖注入、事务管理和异常处理等。适合希望提升代码可维护性和扩展性的开发者参考。
34789737
198 0
运营研究坊
|
7月前
|
人工智能 Java 编译器
Java：面向对象
本文介绍了Java编程中的核心概念，包括包的命名规范与自动导入机制、构造方法的特点与使用、`this`和`super`关键字的作用、继承的基本规则、访问权限的设置、封装的意义、多态的实现原理以及`static`关键字的用法。通过详细解析每个知识点，并结合代码示例，帮助读者深入理解Java面向对象编程的核心思想与实践技巧。内容适合初学者及进阶开发者学习参考。
运营研究坊
170 0
aliyun7741822232-15995
|
9月前
|
缓存 安全 Java
java面试-基础语法与面向对象
本文介绍了 Java 编程中的几个核心概念。首先，详细区分了方法重载与重写的定义、发生阶段及规则；其次，分析了 `==` 与 `equals` 的区别，强调了基本类型和引用类型的比较方式；接着，对比了 `String`、`StringBuilder` 和 `StringBuffer` 的特性，包括线程安全性和性能差异；最后，讲解了 Java 异常机制，包括自定义异常的实现以及常见非检查异常的类型。这些内容对理解 Java 面向对象编程和实际开发问题解决具有重要意义。
aliyun7741822232-15995
163 15
刘大猫.
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
刘大猫.
131 1
雨溪-yuxi
|
JavaScript 前端开发 Java
还不明白面向对象？ 本文带你彻底搞懂面向对象的三大特征（2024年11月Java版）
欢迎来到我的博客，我是瑞雨溪，一名热爱JavaScript和Vue的大一学生。如果你从我的文章中受益，欢迎关注我，我将持续更新更多优质内容。你的支持是我前进的动力！🎉🎉🎉
雨溪-yuxi
128 0
还不明白面向对象？ 本文带你彻底搞懂面向对象的三大特征（2024年11月Java版）

热门文章

最新文章

  • 1
    Java应用频繁FullGC分析
  • 2
    Java常见面试题：泛型中“T”与“？”的区别
  • 3
    深入探索 Java 的@Bean 与 @Component：详尽区别与实际应用
  • 4
    Java高级期末复习：Java EE框架整合开发入门到实战——Spring+Spring MVC+MyBatis微课版
  • 5
    ❤️Java17 发布了，YYDS！重磅！Oracle 宣布 JDK 17 可以免费商用了。。
  • 6
    【java开发系列】—— java输入输出流
  • 7
    java开发——我的开发环境
  • 8
    JAVA 设计模式 策略模式
  • 9
    java socket通信-传输文件图片
  • 10
    在线网络速度测试JAVA程序（一）：思路和控制台主程序【转】
  • 1
    2025 版 Java 零基础入门到精通实操指南
    971
  • 2
    java 入门学习视频_2025 最新 java 入门零基础学习视频教程
    262
  • 3
    顺丰同城抢单辅助脚本，顺丰骑士抢单辅助免封号，自动抢单神器【java版开源】
    818
  • 4
    现代化 java 分层开发实施策略与最佳实践指南
    255
  • 5
    我们详细地讲解一下 Java 异常及要如何处理
    145
  • 6
    MinIO Java SDK 7.1.4 升级到 8.5.17 需要注意什么
    482
  • 7
    微信不封号无限加人软件，微信一键自动加人软件，java实现批量化加人
    148
  • 8
    Java 与 C++ 区别深入剖析及应用实例详解
    550
  • 9
    Java 生态大模型应用开发全流程实战案例与技术路径终极对决
    1015
  • 10
    Java 抽象类与接口在 Java17 + 开发中的现代应用实践解析
    187

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    全面了解阿里云OSS使用方法