（一）学习总结
1.什么是构造方法？什么是构造方法的重载？下面的程序是否可以通过编译？为什么？
public class Test {
public static void main(String args[]) {
Foo obj = new Foo();
}
}
class Foo{
int value;
public Foo(int intValue){
value = intValue;
}
}
构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
（1）在Java中，允许在一个类中定义多个构造方法。
（2）在创建对象时，系统会自动根据所调用的构造方法中包含的参数类型，个数，选择匹配的构造方法创建对象。
（3）构造方法的注意事项
（4）如果在类中没有明确定义构造方法，系统会自动调用默认的构造方法。
（5）如果指定了构造方法，则不调用默认的构造方法。
（6）如果已经指定了有参的构造方法，而又要调用无参的构造方法，则要在类中追加无参构造。
下面的程序不能通过编译，new Foo()错误，应创建构造函数Foo()。
2.运行下列程序，结果是什么？分析原因，应如何修改
public class Test {
public static void main(String[] args) {
MyClass[] arr=new MyClass[3];
arr[1].value=100;
}
}
class MyClass{
public int value=1;
}
数组没有正常初始化，程序只是对arr数组进行了声明，并没有初始化。
修改为：
public class Test {
public static void main(String[] args) {
MyClass[] arr=new MyClass[3];
for(int i=0;i<3;i++){
arr[i]=new MyClass();
}
arr[1].value=100;
}
}
class MyClass{
public int value=1;
}
3.运行下列程序，结果是什么？说明原因。
public class Test {
public static void main(String[] args) {
Foo obj1 = new Foo();
Foo obj2 = new Foo();
System.out.println(obj1 == obj2);
}
}
class Foo{
int value = 100;
}
结果是false，比较的是地址
4.什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明。
封装就是把属性和方法捆绑到一起，封装到一个对象中去，形成一个不可分割的独立单位，修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值方法和赋值方法，用于对这些属性的访问。通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。
public class Worker {
private int no;
private Datet bir,sta;
private String name,sex;
private Home whome;
}
public Worker(String name,String sex,int no,Datet bir,Datet sta) {
this.name=name; this.sex=sex; this.no=no; this.bir=bir; this.sta=sta;
}
public void setbir(Datet bir){
this.bir=bir;
}
public void setsta(Datet sta){
sta=sta;
}
5.阅读下面程序，分析是否能编译通过？如果不能，说明原因。
class A{
private int secret = 5;
}
public class Test{
public static void main(String args[]){
A a = new A();
System.out.println(a.secret++);
}
}
不能，在A定义中对secret进行了封装，在主类函数内无法直接对secret进行操作。可以利用get set 方法，或者将secret变为 public属性。
public class Test{
int x = 50;
static int y = 200;
public static void method(){
System.out.println(x+y);
}
public static void main(String args[]){
Test.method();
}
}
不能正确编译通过，因为没有定义类型为 Test 的对象，Test.method();应该在前面定义一个Test 对象,先在Test的定义里写出定义方法 比如
6.使用类的静态变量和构造方法，可以跟踪某个类创建的对象个数。声明一个图书类，数据成员为编号，书名，书价，并拥有静态数据成员册数记录图书的总数。图书编号从1000开始，每产生一个对象，则编号自动递增（利用静态变量和构造方法实现）。下面给出测试类代码和Book类的部分代码，将代码补充完整。
class Book{
int bookId;
String bookName;
double price;
static int count=1000;
public Book(String bookName, double price) {
this.bookName = bookName;
this.price = price;
}
public int getbookId(){
return bookId;
}
public void setbookId(int bookId){
this.bookId=bookId;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Book() {
count++;
}
public String toString(){
return "图书编号:"+this.bookId+"书名:"+this.bookName+"书价:"+this.price+"产生对象个数:"+count;
}
}
public class Test{
public static void main(String args[]){
Book[] books = {new Book("c语言程序设计",29.3),
new Book("数据库原理",30),
new Book("Java学习笔记",68)};
System.out.println("图书总数为："+"count");
for(Book book:books){
System.out.println(book.toString());
}
}
}
7.什么是单例设计模式？它具有什么特点？用单例设计模式设计一个太阳类Sun。
一个类有且仅有一个实例，并且自行实例化向整个系统提供,实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。节约内存性。缺点是：可能无法访问库源代码，所以可能会意外发现自己无法直接实例化此类。
代码如下：
public class Sun {
private static Sun instance = null;
private Sun() {
}
public synchronized static Sun getInstance() {
if (instance == null) {
instance = new Sun();
}
return instance;
}
}
8.理解Java参数传递机制，阅读下面的程序，运行结果是什么？说明理由。
public class Test {
String str = new String("你好 ");
char[] ch = { 'w','o','l','l','d' };
public static void main(String args[]) {
Test test = new Test();
test.change(test.str, test.ch);
System.out.print(test.str);
System.out.print(test.ch);
}
public void change(String str, char ch[]) {
str = "hello";
ch[0] = 'W';
}
}
你好wolld
9.总结
（1）面向对象
类的定义和实例化调用，重载
重写类成员和实例成员的区别
简单类的设计
掌握String类的常用方法
继承的实现方法
成员变量的继承和隐藏
（2）面向对象高级
多态性
转型
接口和抽象类（概念）
利用接口进行排序
（二）实验总结
1.用面向对象思想完成评分系统
import java.util.Scanner;
import java.util.Arrays;
class Judges {
Scanner in=new Scanner(System.in);
private int judgeer;
private double[] score;
public Judges(){
}
public Judges(int number){
this.judgeer=number;
}
public void setJudgeer(int judgeer){
this.judgeer=judgeer;
}
public void setScore(double[] score){
this.score=score;
}
public int getJudgeer(){
return this.judgeer;
}
public double[] getScore(){
return this.score;
}
public void inputScore(){
score = new double[judgeer];//在输入时进行实例化
for(int j=0;j<judgeer;j++){
score[j]=in.nextDouble();
}
/*for(int i=0;i<judgeer;i++){
System.out.println(score[i]);
}*/
//System.out.println("inputScore"+score);
}
public void maxMin(double[] score){
//System.out.println("maxMin"+score);
Arrays.sort(score);
System.out.println("去掉一个最低分："+score[0]);
System.out.println("去掉一个最高分："+score[judgeer-1]);
}
public double average(double[] score){
//Arrays.sort(score);
double sum=0;
for(int k=1;k<judgeer-1;k++){
sum=sum+score[k];
}
sum=sum/(judgeer-2);
//System.out.println("average"+score);
return sum;
}
}
class Player implements Comparable<Player>{
private String name;//姓名
private int number;//编号
private double score;//得分
public Player(){
}
public Player(int number,String name){
this.name=name;
this.number=number;
this.score=score;
}
public void setName (String name){//setname
this.name=name;
}
public void setNumber(int number){//setnumber
this.number=number;
}
public void setScore(double score){//setscore
this.score=score;
}
public String getName(){//getname
return this.name;
}
public int getNumber(){//getnumber
return this.number;
}
public double getScore(){//getscore
return this.score;
}
public String toString(){
return "编号："+number+","+"姓名："+name+","+"分数"+score+":";
}
public int compareTo(Player o){
if(this.score>o.score){
return -1;
}
else if(this.score<o.score){
return 1;
}
else{
return 0;
}
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Score {
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int numberplay,numberjudge;
System.out.println("输入选手人数");
numberplay=in.nextInt();
Player[] play=new Player[numberplay];
//Player plays=new Player();
System.out.println("输入评委人数");
numberjudge=in.nextInt();
Judges judge=new Judges(numberjudge);
for(int i=0;i<numberplay;i++){
System.out.println("输入选手编号和姓名");
play[i]=new Player(in.nextInt(),in.next());
System.out.println("输入成绩：");
judge.inputScore();//输入成绩
double[] a=judge.getScore();
//System.out.println("a"+a);
judge.maxMin(a);
double score=judge.average(a);
System.out.println("总成绩为："+score);
play[i].setScore(score);
}
Arrays.sort(play);
for(int i=0;i<numberplay;i++){
System.out.println(play[i].toString());
}
}
}
2.Email验证
import java.util.Scanner;
public class DZ {
public static void main(String [] args){
System.out.print("请输入电子邮件地址:");
Scanner sc=new Scanner(System.in);
String str=sc.next();
int first=str.indexOf('@');
int first1=str.indexOf('.');
int last=str.lastIndexOf('.');
if(first<1||first1<1||first>first1||(last==str.length()-1)){
System.out.println(str+"这是一个不合格的地址");
}
else if(first1-first>1){
System.out.println(str+"这是一个合格的地址");
}
else{
System.out.println(str+"这是一个不合格的地址");
}
}
}
3.查找子串
public class CZ {
public static void main(String [] args){
String s ="abcbcaadbca";
String s1=s;//不改变原字符串
int count=0;
while(s1.indexOf("bc")!=-1){
int index=s1.indexOf("bc");
count++;
s1=s1.substring(index+2);//返回字符串从index+2开始到字符串
}
System.out.println(count);
System.out.println(s);
}
}
4.统计文件
import java.util.Scanner;
public class Files {
public static void main(String[] args) {
System.out.println("请输入一串文件名，文件名之间用‘，’隔开：");
Scanner in=new Scanner(System.in);
String str=in.nextLine();
String s[]=str.split(",");//字符串分割
for(int i=0;i<s.length;i++)
{
char []a=s[i].toCharArray();//文件变成字符数组
if(a[0]>=97 && a[0]<=122)
a[0]=(char)(a[0]-32);//如果文件的首字母不是大写，将其变成大写
s[i]=new String(a);//字符数组变成字符串
System.out.println(s[i]);
}
//String a=new String();
for(int i=0;i<s.length;i++)
{
int n=0;
int num=s[i].indexOf(".");//找到后缀名
String str1=s[i].substring(num);
//if(a.indexOf(str1)<0)
//{
//a=a+str1;
for(int j=i;j<s.length;j++)//查找文件
{
//int num2=s[j].indexOf(".");
//String x=s[j].substring(num2);
if(/*str1.equals(x)*/s[j].indexOf(str1)!=-1)//文件类型相同
{
n++;
}
}
System.out.println(str1.substring(1)+"文件有"+n+"个");
//}
}
}
}
5.类的设计
public class Time {
private int year;
private int month;
private int day;
private String birthday;
public String worktime;
private Employee emp;//生日和参加工作时间应属于员工的属性
public void setYear(int year){
this.year=year;
}
public int getYear(){
return this.year;
}
public void setMonth(int month){
this.month=month;
}
public int getMonth(){
return this.month;
}
public void setDay(int day){
this.day=day;
}
public int getDay(){
return this.day;
}
public Time(){
}
public Time(int year1,int month1,int day1,int year2,int month2,int day2){//构造方法
birthday=year1+"-"+month1+"-"+day1;
worktime=year2+"-"+month2+"-"+day2;
}
public void setBirthday(int year,int month,int day){
this.birthday=year+"-"+month+"-"+day;
}
public String getBirthday(){
return birthday;
}
public void setWorktime(int year,int month,int day){
this.worktime=year+"-"+month+"-"+day;
}
public String getWorktime(){
return worktime;
}
public Time(int year,int month,int day){//构造方法
this.year=year;
this.month=month;
this.day=day;
}
/*public String birthday(){
return year+"-"+month+"-"+day;
}
public String worktime(){
return year+"-"+month+"-"+day;
}
}
（三）代码托管[https://gitee.com/hebau_java_cs16/Java_CS01-wyn/tree/master/ex02]
