面向对象（一）综合作业
基础知识：
- 常量的概念，常量有哪几种？编写程序测试。
-
常量的概念：所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
-
常量名一般使用大写字符。
-
程序中使用常量可以提高代码的可维护性。例如，在项目开发时，我们需要指定用户的性别，此时可以定义一个常量 SEX，赋值为 “男”，在需要指定用户性别的地方直接调用此常量即可，避免了由于用户的不规范赋值导致程序出错的情况。
-
java中常量的分类： 整数常量、 小数常量 、布尔常量、字符常量、字符串常量、null常量
package homework01; public class Constant { public static void main(String[] args) { // final 常量名=值; final double PI=3.14; final String LOVE="family"; System.out.println(PI); System.out.println(LOVE); } }
- 变量的本质是什么？编写代码测试。
-
变量的本质：一个变量代表了计算机内存中的一个存储单元，对于这个变量的访问（驱逐和赋值）就是对这个变量所代表存储单元的访问。
package homework01; public class variables { public static void main(String[] args) { //在JAVA中我们通过三个元素来描述变量：变量类型，变量名以及变量值。 String love="family"; System.out.println(love); //变量类型 变量名 值（其中String具有不可变性，重新赋值后会生成新的String对象，love变量名这实际是指向对象地址的引用，"family"为具体的值）。 love="I love my family"; //变量重新赋值，重新指向了一个新的对象，对象值为"i love my family"。 System.out.println(love); } }运行结果： family I love my family
- 方法调用的本质是什么？编写代码测试。
- 方法调用的本质：把实参的值赋给形参，实参和形参占有不同的存储单元，被调用方法执行完以后要返回它被调用的位置，程序继续往下执行。
package homework01; public class MethodInvocation { public static void main(String[] args) { int sum=sum(10,20); System.out.println(sum); } public static int sum(int a ,int b) { return a+b; } } ```
-
什么是数组？请举例说明。
package homework01; public class array { public static void main(String[] args) { //声明数组 语法： 数据类型[ ] 数组名； 或者 数据类型 数组名[ ]； int[] scores; String student[]; //分配空间,简单地说，就是指定数组中最多可存储多少个元素 //语法： 数组名 = new 数据类型 [ 数组长度 ];其中，数组长度就是数组中能存放元素的个数 student = new String[5]; //我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间， String[] names = new String[5]; //赋值，数组中元素都是通过下标来访问的，例如向names中加入学生姓名 names[0] = "张三"; names[1] = "李四"; //也可以将声明数组、分配空间和赋值合并完成 int[] id = {79,91,84,68};//创建一个长度为4的整型数组 //它等价于 int[] ids = new int[]{78,91,84,68};//第二个方括号内必须为空，不能指定长度 } } -
方法的重载（overload）编写代码测试。
-
假设要在程序中实现一个对数字求和的方法，由于参与求和数字的个数和类型都不确定，因此要针对不同的情况去设计不同的方法。程序需要针对每一种求和的情况都定义一个方法，如果每个方法的名称都不同，在调用时就很难分清哪种情况该调用哪种方法。为了解决这个问题，java允许在一个程序中定义多个名称相同的方法，但是参数类型或参数个数必须不同，这就是方法的重载.
package homework01; public class OverLoad { public static void main(String[] args) { //下面是针对求和方法的调用 int sum1 = add(10,20); float sum2 = add(1.23f,0.6f); int sum3 = add(2,4,5,6); //打印求和结果 System.out.println(sum1+" "+sum2+" " +sum3); } //下面方法实现四个整数相加 private static int add(int i, int j, int k, int l) { return i+j+k+l; } //下面方法实现了两个小数相加 private static float add(float f, float g) { return f+g; } //下面方法实现了两个整数相加 public static int add (int a,int b ) { return a+b; } } ```
- 构造方法的重载编写代码测试。
-
构造方法名称与类名相同且没有返回值不能定义为void
package homework01; public class MethondOverLoad { //在创建对象的时候，对象成员可以由构造函数方法进行初始化。 //构造方法的方法名必须与类名一样。 // 构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。 //构造方法的作用是完成对象的初始化工作，他能够把定义对象时的参数传递给对象的域。 //构造方法不能由编程人员调用，而要系统调用。 // 构造方法可以重载，以参数的个数，类型，或排序顺序区分。 String phone; float screen; float cpu; public MethondOverLoad() { super(); } public MethondOverLoad(String phone, float screen, float cpu) { super(); this.phone = phone; this.screen = screen; this.cpu = cpu; } }
- 请举例说明什么是成员变量和局部变量，什么是变量的作用域。
-
成员变量：在类的定义中，用来描述对象将要有什么。
-
局部变量:在类的方法中定义，在方法中临时保存数据。
-
成员变量和局部变量区别：
- 作用域不同:局部变量的作用域仅限于定义它的方法;成员变量的作用域在整个类内部都是可见的
- 初始值不同:Java会给成员变量一个初始值Java不会给局部变量赋予初始值
- 在同一个方法中,不允许有同名局部变量;在不同的方法中,可以有同名局部变量
- 两类变量同名时,局部变量具有更高的优先级
package homework01; public class person { //成员变量 String name; char sex; int age; public void eat(){ //局部变量 int num = 10;//不进行赋值是在方法体内不能用的 编译的时候就会报错 尚未初始化变量 System.out.println(num+"吃"); } public void sleep(){ System.out.println("睡觉"); } }
- Java中的封装是如何实现的？封装的目的是什么？编写代码测试。
-
概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
-
好处：
- 只能通过规定的方法访问数据
- 隐藏类的实例细节，方便修改和实现
-
封装的实现（如图）
package com.imooc; public class Telphonetest { private float screen; private float cpu; private float mem; //通过get 与 set 方法获取private的变量值 public float getScreen() { return screen; } public void setScreen(float newScreen) { screen=newScreen; } public Telphonetest() { System.out.println("无参的构造方法执行了！"); } public Telphonetest(float newScreen,float newCpu,float newMem) { screen = newScreen; cpu = newCpu; mem = newMem; System.out.println("有参的构造方法执行了"); } }package com.imooc; public class Telphone { public static void main(String[] args) { //通过无参的构造方法可以创建对象 Telphonetest phone = new Telphonetest(); //通过有参的构造方法也可以创建对象，并给对象中的实例变量赋初值 Telphonetest phone2 = new Telphonetest(5.0f,1.4f,2.0f); //phone2.cpu=6.0f;当不是private类型变量，可以直接修改 phone2.setScreen(6.0f);//private类型的变量需要通过set或get方法 System.out.println("screen:"+phone2.getScreen()); } }运行结果：
无参的构造方法执行了！ 有参的构造方法执行了 screen:6.0
- 请举例说明this关键字的作用（访问成员变量，调用方法，调用构造方法）
-
this关键字主要有三个应用：
- this调用本类中的属性，也就是类中的成员变量；
- this调用本类中的其他方法；
- this调用本类中的其他构造方法，调用时要放在构造方法的首行。
//第一种应用，访问成员变量 Public Class Student { String name; //定义一个成员变量name private void SetName(String name) { //定义一个参数(局部变量)name this.name=name; //将局部变量的值传递给成员变量 } }//第二种应用，调用本类中的其他构造方法 class Person{ // 定义Person类 private String name ; // 姓名 private int age ; // 年龄 public Person(){ // 无参构造 System.out.println("新对象实例化") ; } public Person(String name){ this() ;// 调用本类中的无参构造方法 this.name = name ; } public Person(String name,int age){ // 通过构造方法赋值 this(name) ;// 调用有一个参数的构造方法 this.age = age ;// 为类中的age属性赋值 } public String getInfo(){ // 取得信息的方法 return "姓名：" + name + "，年龄：" + age ; } }; public class ThisDemo06{ public static void main(String args[]){ Person per1 = new Person("张三",33) ; // 调用构造实例化对象 System.out.println(per1.getInfo()) ; // 取得信息 } };//第三种应用，调用本类中的其他方法 class Person{ private String name; private int age; public Person() { } public Person(String name,int a) { this.name=name; this.age=age; this.print();//调用本类方法 } public void print() { System.out.println("*********************"); } public String getInfo() { return "姓名： "+this.name+" 年龄："+this.age; } } public class StringDemo { public static void main(String args[]) { System.out.println(new Person("张三",20).getInfo()); } } 结果//********************* 姓名： 张三 年龄：0
- static关键字的作用（修饰成员变量，修饰方法）编码测试
-
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问~~
-
使用 static 可以修饰变量、方法和代码块。
package com.imooc; public class Hello { //使用static关键字声明静态方法 public static void print() { System.out.println("欢迎光临！"); } public static void main(String[] args) { //直接使用类名调用静态方法 Hello.print(); //也可以通过对象名调用，当然更推荐使用类名调用的方式 Hello demo=new Hello(); demo.print(); } } -
注意：静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如：
package com.imooc; public class Mooc { String name = "爱慕课";//非静态变量name static String hobby = "imooc";//静态变量hobby //在静态方法中调用非静态变量 public static void print() { System.out.println(hobby);//可以调用静态变量 System.out.println(name);//错误，不可调用非静态变量 } } -
如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
-
内部类的概念，编写代码测试成员内部类。
问：什么是内部类呢？
答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
答：内部类的主要作用如下：
a. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
b. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
c. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
问：内部类有几种呢？
答：内部类可分为以下几种：
成员内部类 静态内部类 方法内部类 匿名内部类
-
内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码:
package com.imooc; public class Outer { private int a = 99;//外部类的私有属性 //内部类Inner public class Inner{ int b = 2;//内部类的成员属性 public void test() { System.out.println("访问外部类的a：" + a); System.out.println("访问内部类的b：" + b); } } //测试成员内部类 public static void main(String[] args) { Outer o = new Outer();//创建外部类对象，对象名为o Inner i = o.new Inner();//使用外部类对象创建内部类对象，对象名为i i.test();//调用内部类对象的test方法 } }从上面的代码中我们可以看到，成员内部类的使用方法：
a、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等
b、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a
c、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );
d、 编译上面的程序后，会发现产生了两个 .class 文件
其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class另外，友情提示哦：
a. 外部类是不能直接使用内部类的成员和方法滴
可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。b. 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：
面向对象的内存分析：
参考com.huaxin.task01中的代码及006_案例01内存分析_02.png图片，自己执行代码画图。（此图很重要）
作业要求：所有代码在eclipse中测试通过，敲三遍，手写一遍，开学检查。
4154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
