第二次作业

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; 　　　　　　//封装在com.cvit包　　　　　　 
interface Flyer　　　　　 　　//创建接口Flyer
{
　　public void takeOff(); //无返回值方法 takeOff()　　　
　　public void land();    //无返回值方法 land()　　
　　public void fly();     //无返回值方法 fly()
}

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

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

package com.cvit;                         　　　　//封装com.cvit包
public class Airplane implements Flyer　　　　　　//创建类Airplane
{
　　public void takeOff()            　　　　　　　//无返回值方法 takeOff()
{
　　System.out.println("----------------");    　//打印输出第一行"----------------"
　　System.out.println("airplane takeOff");　　　//打印输出第二行"airplane takeOff"

}
　　public void land()　　　　　　　　　　　　　　　//无返回值方法 land()
{
　　System.out.println("----------------");　　 //打印输出第一行"----------------"
　　System.out.println("airplane land");　　　  //打印输出第二行"airplane land"
}
　　public void fly()　　　　　　　　　　　　　　　//无返回值方法 fly()
{
　　System.out.println("----------------");　　//打印输出第一行"----------------"
　　System.out.println("airplane fly");　　　　//打印输出第二行"airplane fly"
}

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

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

package com.cvit;                         　　　　　　　　　//封装com.cvit包
public class SuperClass　　　　　　　　　　　　　　　　　　　　//创建类SuperClass
{
　　　　int x;　　　　　　　　　　　　　　　　　　　　　　　　　 //声明整型变量x
　　　　public void Superclass()　　　　　　　　　　　　　　　//创建构造方法
　　{
　　　　x=4;                                              //为x赋值为4
　　　　System.out.println("in subClass:x="+x);           //打印输出"in superClass : x = [x的值]"
　　}
　　　　public void aMethod()                             //定义方法aMethod()
　　{
　　　　System.out.println("in superClass.aMethod()");    //打印输出"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的值

package com.cvit; 　　　　　　　　　　　　　　　　　　//封装在com.cvit包　　　　　　 
class SubClass1 extends SuperClass　　　　　　　　 //创建类SubClass1继承SuperClass
{
    public int x;    　　　　　　　　　　　　　　　　//声明整型变量x
    public SubClass1()　　　　　　　　　　　　　　　//创建构造方法　　　　　　　　　　　　　　　　
    {
        x=6;        　　　　　　　　　　　　　　　　//x赋值为6
        System.out.println("in subClass:x="+x);//打印输出"in subClass : x = [x的值]"
    }
    public void aMethod()　　　　　　　　　　　　　//定义方法aMethod()　　　　　　　　　　　　　
    {
        super.aMethod();    　　　　　　　　　　　//调用父类的构造方法
        System.out.println("in SubClass1.aMethod()");    　//打印输出"in SubClass1.aMethod()"
        System.out.println("super.x="+super.x+"sub.x="+x);//打印输出"super.x = [父类中x的值], sub.x=[子类中x的值]"
    }
        public int aMethod(int a,int b)　　　　　//定义方法aMethod(int a, int b)，返回a+b的值　　　
    {
        int s=a+b;                    　　　　　　//定义a+b
        return s;                               //返回a+b的值
    }
}

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

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

package com.cvit; 　　　　　　　　　　　　　　　　　　　　　 //封装在com.cvit包　　　　　
class SubClass2　　　　　　　　　　　　　　　　　　　　　　　//创建类SubClass2　　　　　　　　　　　 　　　 　　　　　　　　　　　　　　　　　　　
{
    public void aMethod()　　　　　　　　　　　　　　　　　//定义方法aMethod()
　　　　　　　　　　　　
    {    
        System.out.println("in SubClass2.aMethod()");//打印输出"in SubClass2.aMethod()"
    }
    public int aMethod(int a ,int b)　　　　　　　　　 //定义方法aMethod(int a, int b)　　　　　　
    {
        int s=a+b;　　　　　　　　　　　　　　　　　　　　//定义a+b
        return s;　　　　　　　　　　　　　　　　　　　　 //返回a+b的值
    }
}

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

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

package com.cvit; 　　　　　　　　　　　　　　　　　　　　　//封装在com.cvit包　　　　　
class SubClass3　　　　　　　　　　　　　　　　　　　 　　　//创建类SubClass3　　　　　　　　　　　 　　　 　　　　　　　　　　　　　　　　　　　
{
    public void aMethod()　　　　　　　　　　　　　 　　　//定义方法aMethod()
　　　　　　　　　　　　
    {    
        System.out.println("in SubClass3.aMethod()");//打印输出"in SubClass3.aMethod()"
    }
    public int aMethod(int a ,int b)　　　　　　　　　　//定义方法aMethod(int a, int b)　　　　　　
    {
        int s=a+b;　　　　　　　　　　　　　　　　　　　　　//定义a+b
        return s;　　　　　　　　　　　　　　　　　　　　　//返回a+b的值
    }
}

　　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方法；

package com.cvit; 　　　　　　　　　　　　　　　　　　　　　　　　　　//封装在com.cvit包　　　　　
public class Main　　　　　　　　　　　　　　　　　　　　　　　　　　//创建主类main　　　　　　　　　　　　　　　　　　　　 
{
    public static void chooseClass(SubClass2 sub2)　　　　　//定义返回值为空的静态方法chooseClass(SubClass2 sub2)　　　　　 
    {
    }
    public static void chooseClass(SubClass3 sub3) 　　　　//定义返回值为空的静态方法chooseClass(SubClass3 sub3)
    {
    }
    public static void main (String args[])　　　　　　　　//程序的入口　　　　　　　　　　　　
    {
        int x=7;　　　　　　　　　　　　　　　　　　　　　　　　　　//定义整型变量x，赋值为7
        Airplane airplane=new Airplane();　　　　　　　　　　　//创建Airplane类的对象airplane；　　　　　　　　　　　　
        airplane.takeOff();　　　　　　　　　　　　　　　　　　　//调用Airplane类的takeOff方法；　　　　　　　　　　　　　
        SubClass1 sub1=new SubClass1();　　　　　　　　　　　　//创建SubClass1类的对象sub1；
        sub1.aMethod();　　　　　　　　　　　　　　　　　　　　　　//调用SubClass1类的aMethod方法；
        int a =sub1.aMethod(x,x);　　　　　　　　　　　　　　　　//传值(x, x)，将得到的结果赋值给a；　　　　　　　　　　　　　　　　　　
        System.out.println(a);　　　　　　　　　　　　　　　　　　//用a承接返回值
        airplane.fly();　　　　　　　　　　　　　　　　　　　　　　//调用Airplane类的fly方法；
        SubClass2 sub2=new SubClass2();　　　　　　　　　　　　//创建SubClass2类的对象sub2；
        SubClass3 sub3=new SubClass3();　　　　　　　　　　　　//创建SubClass3类的对象sub3；
        chooseClass(sub2);　　　　　　　　　　　　　　　　　　　　//调用chooseClass方法；　　　　　　　　　　　　　　　　　　　　　
        int b =sub2.aMethod(x,x);　　　　　　　　　　　　　　　　//将sub2作为参数传入;
        System.out.println(b);　　　　　　　　　　　　　　　　　　//用b承接返回值;
        chooseClass(sub3);　　　　　　　　　　　　　　　　　　　　//调用chooseClass方法，将sub3作为参数传入；
        int c =sub3.aMethod(x,x);　　　　　　　　　　　　　　　　//将sub3作为参数传入c；
        System.out.println(c);　　　　　　　　　　　　　　　　　　//用c承接返回值;
        airplane.fly();　　　　　　　　　　　　　　　　　　　　　　//调用Airplane类的fly方法；
    }
}

3.运行结果：