标签：重载 代码行数 port 允许 时间 抽象类 protected str --
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();
}
}
第二次作业
标签：重载 代码行数 port 允许 时间 抽象类 protected str --
原文地址：http://www.cnblogs.com/niupitangtang/p/7853704.html
