第二次作业

Posted 2020-10-14 牛皮糖啊

1.个人学习进度条：

	代码行数（新增/累积）	博客字数（新增/累积）	学习时间（新增/累积）	重要成长
目标	1000行	5000	100小时	掌握程序设计的思想
第十一周	100/100	500/500	10/10	学习了结Java绪论
第十二周	200/200	0/0	20/10	学习了解结构化程序设计
第十三周	300/300	2000/2000	30/20	学习了解面向对象程序设计
第十四周	…	…	…	…

2.面向对象程序设计知识梳理：

　　面向对象技术的三大特性：继承性、多态性和封装性

　　（1）类：类是程序设计的基本单位

　　　　　类的定义：[修饰词] class 类名

　　　　　　　　　　{

　　　　　　　　　　　　类体（属性和方法）

　　　　　　　　　　}

　　（2）方法：方法即函数，是一种动作，而属性是名词

　　　　　方法的定义：[修饰词] 返回值类型 方法名（[方法的参数列表]）

　　　　　　　　　　{

　　　　　　　　　　　　方法体

　　　　　　　　　　}

　　　　构造方法：每个类都有的，方法名和类名相同的，不返回任何数据类型且不需要用void声明的一种方法

　　（3）对象：类是抽象而对象是具体

　　　　　对象的创建：类名 对象名 = new 构造方法名

　　　　　实例对象方法的调用：对象名.方法名()

　　　　　传值和传引用的区别：传值操作变量，地址不变，赋值；传引用操作对象，赋地址。

　　（4）继承性：

　　　　　子类继承父类，定义格式：

　　　　　　　　　　[修饰词] class 类名 extends 父类名 [implements 接口名称A,B,C]

　　　　　　　　　　{

　　　　　　　　　　　　类体（属性和方法）

　　　　　　　　　　}

　　　　　注：Java不支持多重继承，允许一个类有多个直接父接口interface

　　　　　　　子类在创建对象时，会先调用父类的默认构造方法在调用子类的构造方法

　　（5）多态性：代码可重用，起的名可以一样

　　　　　静态多态性：重载---在编译时就能被识别，同一个类中同名但不同参数的方法，先调用父类的再调用子类的

　　　　　动态多态性：覆盖---在运行的时候才能够看出来，子类和父类有相同的方法（包括参数列表），调子类的

　　　　　super：表示当前对象的父类

　　　　　　　　　super.成员名---用super访问父类被覆盖的成员

　　　　　　　　　super.方法名()---用super访问父类被覆盖的方法

　　　　　　　　　super([参数列表])---用super调用父类的构造方法

　　（6）包：同一包内的类可以相互访问，对其他包中的类提供访问控制;方便程序重用

　　　　　创建包：package 包名

　　　　　导包：

　　　　　　import 包名.*　　　　//全部类

　　　　　　import 包名.类名

　　　　　　import static 包名.静态方法名

　　　　　注：包中含有“.”分隔符，表示目录层次；

　　　　　　　成员与方法前必须加上public，否则引入包会出错；

　　　　　　　一个Java文件只能有一个包；

　　　　　　　编译Java文件：javac -d 目录名 源文件.java 

　　（7）封装性：

　　　　　类成员的访问控制模式及允许访问范围：

　　　　　公共模式public:在同一类内，在同一包内，子类，所有类可以访问

　　　　　保护模式protected:在同一类内，在同一包内，子类可以访问

　　　　　默认模式default:在同一类内，在同一包内可以访问

 

　　　　　私有模式private:在同一类内可以访问

　　（8）关键字：

　　　　　abstract抽象： 抽象类不能用来创建对象，必须被继承；

　　　　　　　　　　　　抽象方法不能有方法体；

　　　　　　　　　　　　抽象方法不一定包含抽象方法但抽象方法必须在抽象类中；

　　　　　　　　　　　　抽象类的子类必须把父类省略的方法体写出来

　　　　　static静态：不属于任何一个具体对象，属于类，开辟的空间是公共的

　　　　　final最终：被final修饰不能有子类，常量被赋值，值不可以被更改

第二次作业

1. 创建接口Flyer，封装在com.cvit包中，包含三个方法    

• 无返回值 takeOff()
• 无返回值 land()
• 无返回值 fly()

package com.cvit; 　　　　　　　　　　 

interface Flyer

{

public void takeOff(); 　　　　

public void land();

public void fly();

}

2. 创建类Airplane，封装在com.cvit包中，实现Flyer接口

• 无返回值 takeOff()，打印输出第一行"----------------"，第二行"airplane takeOff"
• 无返回值 land()，打印输出第一行"----------------"，第二行"airplane land"
• 无返回值 fly()，打印输出第一行"----------------"，第二行"airplane fly"

class Airplane implements Flyer 　　　　　　　　　　

{

public void takeOff() 　　　　　　　　　　 

{

System.out.println("------------");　　　　

System.out.println("airplane takeOff");

　　　　　　..

　　　　　　..

}

3. 创建类SuperClass，封装在com.cvit包中

• 声明整型变量x，
• 构造方法实现以下功能，为x赋值为4，打印输出"in superClass : x = [x的值]"
• 定义方法aMethod()，打印输出"in superClass.aMethod()"

class SuperClass 　　　　　　　　　　　　　　　　　　

{

public int x; 　　　　　　　　　　　　　　　　　　　　

public SuperClass()　　　　　　　　　　　　　　　　　　　　　

{

x=4;

System.out.println("in superClass:x="+x);

}

public void aMethod()　　　　　　　　　　　　　　　　　　　 

{

System.out.println("in superClass.aMethod()");

}

}

4. 创建类SubClass1，封装在com.cvit包中

• 声明整型变量x，
• 构造方法实现以下功能，为x赋值为6，打印输出"in subClass : x = [x的值]"
• 定义方法aMethod()
  调用父类的构造方法；
  打印输出"in SubClass1.aMethod()"；
  打印输出"super.x = [父类中x的值], sub.x=[子类中x的值]"；
• 定义方法aMethod(int a, int b)，返回a+b的值

 

class SubClass1 extends SuperClass　　　　　　　　　　　　　

{

public int x;

public SubClass1()　　　　　　　　　　　　　　　　　　

{

x=6;

System.out.println("in subClass:x="+x);

}

public void aMethod()　　　　　　　　　　　　　　　　　

{

super.aMethod();

System.out.println("super.x="+super.x+"sub.x="+x);

}

public int aMethod(int a,int b)　　　　　　　　　　

{

int s=a+b;

return s;

}

}

5. 创建类SubClass2，封装在com.cvit包中

• 定义方法aMethod()，打印输出"in SubClass2.aMethod()"
• 定义方法aMethod(int a, int b)，返回a+b的值

class SubClass2　　　　　　　　　　　　　　　　　　 　　　 　　　　　　　　　　　　　　　　　　　

{

public void aMethod()　　　　　　　　　　　　　　　　　

{

System.out.println("in SubClass2.aMethod()");

}

public int aMethod(int a ,int b)　　　　　　　　　　　

{

int s=a+b;

return s;

}

}

6. 创建类SubClass3，封装在com.cvit包中

• 定义方法aMethod()，打印输出"in SubClass3.aMethod()"
• 定义方法aMethod(int a, int b)，返回a+b的值

 

class SubClass3　　　　　　　　　　　　　　　　　　　　　　　　 

{

public void aMethod()　　　　　　　　　　　　　　　　 

{

System.out.println("in SubClass3.aMethod()");

}

public int aMethod(int a ,int b)　　　　　　　　　　

{

int s=a+b;

return s;

}

}

7. 创建主类Main，封装在com.cvit包中

• 定义返回值为空的静态方法chooseClass(SubClass2 sub2)
• 定义返回值为空的静态方法chooseClass(SubClass3 sub3)
• 程序的入口方法实现
  定义整型变量x，赋值为7；
  创建Airplane类的对象airplane；
  调用Airplane类的takeOff方法；
  创建SubClass1类的对象sub1；
  调用SubClass1类的aMethod方法；
  调用SubClass1类的aMethod方法，传值(x, x)，将得到的结果赋值给x；
  调用Airplane类的fly方法；
  创建SubClass2类的对象sub2；
  创建SubClass3类的对象sub3；
  调用chooseClass方法，将sub2作为参数传入；
  调用SubClass2类的aMethod方法，传值(x, x)，将得到的结果赋值给x；
  调用chooseClass方法，将sub3作为参数传入；
  调用SubClass3类的aMethod方法，传值(x, x)，将得到的结果赋值给x；
  调用Airplane类的fly方法；

 

public class Main　　　　　　　　　　　　　　　　　　　　　　　　　　 

{

public static void chooseClass(SubClass2 sub2)　　　　　　 

{

 

}

public static void chooseClass(SubClass3 sub3)

{

 

}

public static void main (String args[])　　　　　　　　　　　　　　

{

int x=7;

Airplane airplane=new Airplane();　　　　　　　　　　　　　

airplane.takeOff();　　　　　　　　　　　　　　　　　　　　　　

SubClass1 sub1=new SubClass1();

sub1.aMethod();

int a =sub1.aMethod(x,x);　　　　　　　　　　　　　　　　　　　

System.out.println(a);

airplane.fly();

SubClass2 sub2=new SubClass2();

SubClass3 sub3=new SubClass3();

chooseClass(sub2);　　　　　　　　　　　　　　　　　　　　　　

int b =sub2.aMethod(x,x);

System.out.println(b);

chooseClass(sub3);

int c =sub3.aMethod(x,x);

System.out.println(c);

airplane.fly();

}

}