《java基础入门课后习题》

第五章

/**功能：通过继承Thread类的方式创建两个线程，在Thread线程中指定线程的名称并将这两个线程的名字打印出来*/
package exercise;
import java.lang.Thread;
public class Chapter5_6_1{
public static void main(String [] args){
 MyThread t1=new MyThread("我的自定义线程00000000000");
 t1.start();
 MyThread t2=new MyThread("我的自定义线程线程11111");
 t2.start();
 
 }
}
class MyThread extends Thread{//通过继承thread的方法创建一个线程类
 MyThread(String name){//构造方法初始化线程
  super(name);
 }
 public void run(){//重写线程的run方法
  //while(true){
   System.out.println(getName()+">->->->->->->->->->");
  //}
 }
} 

 
照片名称：5-6-1
---------------------------------------------------------------------------------------------------------
/**功能：通过实现runnable接口的方式来创建一个新线程，要求main线程打印100次main，新线程打印50次new*/
package exercise;
import java.lang.*;
public class Chapter5_6_2{
 public static void main(String[] args){
  int count=0;
  MyThread2 mt2=new MyThread2();//创建任务
  Thread t=new Thread(mt2);//将任务封装进
  t.start();//开启
  for(int i=0;i<100;i++){
   count++;
   System.out.println("main..........."+count);
  }
 }
}
class MyThread2 implements Runnable{//通过实现Runnable接口的方法来创建一个线程类
 int count=0;
 public void run(){//实现接口中的run方法将线程任务封装
  for(int i=0;i<50;i++){
   count++;
   System.out.println("new........................... "+count);
  }
 }
} 

照片名称：5-6-2
照片名称：5-6---2 
---------------------------------------------------------------------------------------------------------
/**功能：模拟三个老师同时发80份学习笔记，每个老师相当于一个线程
思路：1：三个老师就是三个线程，所以需要一个线程类
     2:80份作业就是任务。将任务封装到线程中
    3：有共享资源就得，三个线程同时访问，就得需要在任务中加锁
   4：利用测试类测试*/
package exercise;
import java.lang.*;
public class Chapter5_6_3{
 public static void main(String[] args){
  Teacher tc=new Teacher();
  /*将创建的一个任务封装到三个线程中*/
  Thread t1=new Thread(tc,"老师1");
  t1.start();
  Thread t2=new Thread(tc,"老师2");
  t2.start();
  Thread t3=new Thread(tc,"老师3");
  t3.start();
 }
}
class Teacher implements Runnable{//实现Runnable接口来将任务封装
 Notes n=new Notes();
  public void run(){
  
  n.distribute();
  
 }
}
class Notes{
 private int notes_num=80;
 
 private Object obj=new Object();//创建一个锁
  void distribute(){
  while(true){
   synchronized(obj){//利用同步达到线程间的互斥
    if(notes_num>=0){
    
    try{Thread.sleep(10);}catch(InterruptedException e){}
    System.out.println(Thread.currentThread().getName()+"剩余作业.........."+notes_num--);
    }
    else{
     break;
    }
   }
  }
 }
}

照片名称：5-6-3
---------------------------------------------------------------------------------------------------------
/**功能：编写10个线程，第一个线程从1加到10，第二个线程从11加到20......第十个线程从从91加到100，最后把十个线程的结果相加
 分析：根据题可以分析出该题为十个线程，执行十个任务，然后将是个人物累加共享一个数据资源；
 思路：是个线程十个任务，就是创建十个线程，将任务封装到十个线程内部。用一个变量记下每个线程累加的数，然后将该变量累加到共享数据上即可*/
package exercise;
import java.lang.*;
public class Chapter5_6_4{
 public static int sum=0;//创建类内部的线程共享数据
 public static void main(String[] args){
  /*用于创建并开启十个线程，并将十个任务封装到是个线程的内部*/
  for(int i=0;i<10;++i){
   MyThread  t=new MyThread();
   t.init(i);
   Thread th=new Thread(t);
   th.start();
   
  }
  /*此处利用sleep方法来延缓主线程的执行速度，避免出现十个线程还未累加完毕，主线程就将累加完毕的线程总和打印到控制台中，出现结果不唯一的情况*/
  try{Thread.sleep(100);}catch(InterruptedException e){}
  System.out.println("十个线程最终相加的结果是：->"+sum);
 }
}
/*通过实现Runnable接口的方式创建线程类，将任务封装*/
class MyThread implements Runnable{
 private  int num;//定义一个可以记录每个线程起始累加数的变量
 private static Object obj=new Object();//定义一个锁，用于将来十个现成完成共享数据的累加时的互斥
 public void init(int num){//用来初始化每个线程初始累加数
  this.num=num;
 }
 public void run(){//重写run方法
  int count=0;//记录每个线程累加结果的变量
  for(int i=num*10+1;i<num*10+11;++i)count+=i;//每个线程累加
  synchronized(obj){
   System.out.println(Thread.currentThread().getName()+"累加结果........"+count);
   Chapter5_6_4.sum+=count;//共享数据的累加
  }
 }
 
}

照片名称：5-6-4
-------------------------------------------------------------------------------------------------

第六章

/**功能：编写一个程序，实现字符串的大小写转换并倒序输出要求如下
   1：使用for循环将字符串hello world 从最后一个字符开始遍历。
   2：遍历的当前字符如果是大写字符，就使用toLowerCase()方法将其转换为小写字符，反之，将其
   则使用toUpperCase()方法将其转换为大写字符
   3：定义一个StringBuffer对象，调用append（）方法一次添加遍历的字符，最后调用StringBuffer
   的toString()方法，并将得到的结果输出。*/
package exercise;
class Chapter6_6_1{
 public static void main(String[] args){
  MyString ms=new MyString();
  System.out.println("转换前的字符：HelloWord");
  System.out.println("转换并倒序后的字符：");
  System.out.println(ms.change("Hello Word"));
 }
}
class MyString{//将转变功能封装到一个类中
 public String change(String s){//实现转换的方法
  char[] c=s.toCharArray();//定义一个字符数组并将字符串转换为字符数组
  StringBuffer sb=new StringBuffer();//定义一个字符缓冲区
  for(int i=c.length-1;i>=0;i--){//倒叙遍历数组
   if(Character.isLowerCase(c[i])) {//判断是否为小写
    sb.append(Character.toUpperCase(c[i]));//转换为大写并加入缓冲区
    }
   else if(Character.isUpperCase(c[i])){
    sb.append(Character.toLowerCase(c[i]));
    }
   }
  return sb.toString();//将字符串缓冲区转化为字符串返回。
 }
}

照片名称：6-6-1
--------------------------------------------------------------------------------------------
/**功能：计算从今天起，100天以后是几月几号，并格式化成xxxx年xx月的形式打印出来
  1：调用Calendar类的add（）方法，计算100天后的日期
  2:调用Calendar类的getTime()方法返回Date类型对象
  3：使用FULL格式的DateFormat对象，调用format()方法格式化Date对象
         思路：   1：要调用方法首先得产生一个对象。利用Calendar.getInstance()获取一个日历实例
        2：调用这个实例的add（）方法将时间偏移100天
        3：利用这个实例的getTime()方法返回当前时间的Date对象
        4：创建一个DateFormat对象，利用该对象实例将Date对象实例化*/
package exercise;
import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
public class Chapter6_6_2{
 public static void main(String[] args){
  MyClendar mc=new MyClendar();
  mc.fun();
 }
}
class MyClendar{

 public void fun(){
    Calendar cl=Calendar.getInstance();//利用静态方法获取一个日历实例
    System.out.println("电脑的当前日期以及时间为："+cl.getTime());
    cl.add(cl.DATE, 100);//将当前的天数偏移100天
    Date da=cl.getTime();//获取当前时间的date对象
  //利用静态方法获取DateFormat对象
    DateFormat df=DateFormat.getDateInstance(DateFormat.FULL);
    System.out.println("一百天后的日期为：");
    System.out.println(df.format(da));//利用dateformat将当前时间格式化后输出
   
 }
}

照片名称：6-6-2
---------------------------------------------------------------------------------------------
/**功能：利用Random类来产生5个20~50之间的随机数。
 */
package exercise;
import java.util.Random;
public class Chapter6_6_3{
 public static void main(String[] args){
 MyRandom md=new MyRandom();
 md.randomProducter(20, 50);
 }
}
class MyRandom{
 public void randomProducter(int n,int m){
  System.out.println("产生的随机数为:");
  for(int i=0;i<5;i++){
   int j=n+(new Random()).nextInt(m-n+1);
   System.out.println(j);
  }
 }
}

照片名称：6-6-3
---------------------------------------------------------------------------------------------------

第七章

/**功能：利用Arraylist集合，对其添加10个不同的元素，并用Iterator遍历该集合。*/
package exercise;
import java.util.ArrayList;
import java.util.Iterator;
public class Chapter7_6_1{//测试类
 public static void main(String[] args){
    MyCollection1.myAdd();
    MyCollection1.myGet();
 }
  }
 class MyCollection1{//封装自己的添加和取出的操作
 static ArrayList al=new ArrayList();//定义一个容器
 public static void myAdd(){//添加方法
 al.add("haha");
 al.add("java");
 al.add(52);
 al.add(0.1314);
 al.add(3.1415926);
 al.add(true);
 al.add("hehe");
 al.add("flase");
 al.add("你好");
 al.add("sql");
 System.out.println("集合中加入的元素是：");
 System.out.println("haha"+"  "+"java"+"  "+52+"  "+0.1314+"  "+3.1415926);
 System.out.println(true+"  "+"hehe"+"  "+"flase"+"  "+"你好"+"  "+"sql");
 }
 public static void myGet(){//取出方法
  Iterator it=al.iterator();
  System.out.println("集合中取出的元素为：");
  while(it.hasNext()){
   Object str=it.next();
   System.out.println(str);
  }
 }
 
}
 
照片名称：7-6-1
---------------------------------------------------------------------------------------------------------
 /**功能：在HashSet集合中添加三个Person对象，把姓名相同的人当作同一个人静止重复添加。
 * 思路：1：首先HashSet判断是否重复的原理是，它与treeMap()不同。不能进行排序。判断
 * 重复的依据是equals()方法和hashCode()方法的返回结果是否相同。容器先根据系统产生的hashSet()
 * 是否相同，如果相同则根据equals()方法来比较内容。
 *     2:要根据自己的要求添加是否相同的对象就需要重写这两个方法 */
package exercise;
import java.util.HashSet;
import java.util.Collection;
import java.util.Iterator;
public class Chapter7_6_2{
 public static void main(String[] args){
  Person p1=new Person("张三",20);
  Person p2=new Person("张四",20);
  Person p3=new Person("张五",20);
  Person p4=new Person("张三",22);
  System.out.println("要加入的对象姓名为:");
  System.out.println(p1.getName());
  System.out.println(p2.getName());
  System.out.println(p3.getName());
  System.out.println(p4.getName());
  MyCollection2.myAdd(p1);
  MyCollection2.myAdd(p2);
  MyCollection2.myAdd(p3);
  MyCollection2.myAdd(p4);
  MyCollection2.myGet(MyCollection2.hs);
  
  
 }
}
class Person{//定义Person类
 String name;
 int age;
 public Person(String name, int age) {//person类的构造方法
  this.name = name;
  this.age = age;
 }
 /*获取和设置姓名年龄的方法*/
  String getName() {
   return name;
  }
  void setName(String name) {
   this.name = name;
  }
  int getAge() {
   return age;
  }
  void setAge(int age) {
   this.age = age;
  }
 public int hashCode() {//重写hashCode（）方法。
  return this.name.hashCode();//Object方法的hashCode返回的是系统分配的哈希值，此处自定义
 }

 public boolean equals(Object obj) {
  Person p=(Person)obj;
  return this.name.equals(p.name);//重写了比较内容的语句
 }
  
}
class MyCollection2{//对容器的操作封装方法
 public static HashSet<Person> hs=new HashSet<Person>();//定义一个只能装person对象的容器
 public static void myAdd(Person p){//添加方法
  hs.add(p); 
 }
 public static void myGet(Collection<Person> e){//取出元素的方法，利用泛型限定传进容器的类型
  Iterator<Person> it=e.iterator();//利用泛型限定取出元素的类型可以省略取出时的类型转换
  while(it.hasNext()){
   System.out.println("集合中取出的元素：......"+it.next().getName());//由于利用了泛型，此处的类型转换省略
  }
  
 }
}

照片名称：7-6-2
------------------------------------------------------------------------------------------------
/**功能：选择合适的Map集合保存5位学员的学号和姓名，然后按学号的自然顺序的倒序将这些键值对应一一打
 * 印出来
 * 思路：1:要排序自然想到的是TreeMap()
 *     2:要按自己的要求排序自然得实现comparable接口来定义自己的排序规则
 *     3：存取元素按容器的操作方法来操作*/
package exercise;
import java.util.Comparator;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
class Chapter7_6_3{
 public static void main(String[] args){
  Students s1=new Students(1,"Lucy");
  Students s2=new Students(2,"John");
  Students s3=new Students(3,"Smith");
  Students s4=new Students(4,"Aimee");
  Students s5=new Students(5,"Amanda");
  MyCollections3.myadd(s1);
  MyCollections3.myadd(s2);
  MyCollections3.myadd(s3);
  MyCollections3.myadd(s4);
  MyCollections3.myadd(s5);
  MyCollections3.myget(MyCollections3.m);
  
 }
}
/*定义一个学生类，封装了一系列的属性*/
class Students{
 
 int snum;
 String name;
 Students(int snum,String name){
  this.name=name;
  this.snum=snum;
 }
 int getSnum() {
  return snum;
 }
 void setSnum(int snum) {
  this.snum = snum;
 }
 String getName() {
  return name;
 }
 void setName(String name) {
  this.name = name;
 }
 
}
/*将添加元素和获取元素的功能封装*/
class MyCollections3{
 //定义集合
 public static Map<Integer,Students> m=new TreeMap<Integer,Students>(new MyComparatorBySN());
 public static void myadd(Students s){//添加方法
  m.put(s.snum, s);
 }
 public static void myget(Map<Integer,Students> c){//利用泛型限定存储类型
  Set<Entry<Integer, Students>> entrySet=c.entrySet();//定义存储entrySet的集合
  Iterator it=entrySet.iterator();
  while(it.hasNext()){
   Map.Entry<Integer, Students> me=(Entry<Integer, Students>) it.next();//取到entrySet
   Integer num=me.getKey();//通过entrySet取到键
   Students s=me.getValue();//通过entrySet取到值
   System.out.println("键："+num);
   System.out.println("值："+"姓名："+s.name+"....."+"学号："+s.snum);
  }
  
 }
}
class MyComparatorBySN implements Comparator{//实现Comparator方法自定义他的比较方法
 public int compare(Object o1, Object o2) {
  
  return (Integer)o2-(Integer)o1;
 }
 
}

照片名称：7-6-3
---------------------------------------------------------------------------------------------

第八章

/**功能：编写一个程序，分别使用字节流和字符流拷贝一个文本文件
   思路：1:打开文件，读取文件需要抛出异常，代开文件失败异常
  2：读取文件，硬盘上的文件，字符流要用FileWriter和FileReader，字节流用FileInputStream ,FileOutputStream
  3：复制文件,循环读取文件，提高效率用BufferReader，BufferWrite,以及自定义缓冲区，确定目标文件，确定目标文件
  4：关闭流close。
    */
package exercise;
import java.io.*;
public class Chapter8_6_1{
 public static void main(String[] args) throws IOException{
  copy_1();
  copy_2();
 }
 public  static void copy_1() throws IOException {
    /*文件输入字节流，此处为本机绝对路径*/
       FileInputStream fin=new FileInputStream("E:\\code\\Java\\practice.java\\src\\exercise\\我的文件复制案例.txt");
       /*文件输入字节缓冲流*/
       BufferedInputStream bfin=new BufferedInputStream(fin);
       /*文件输出字节流*/
       FileOutputStream fou=new FileOutputStream("E:\\code\\Java\\practice.java\\src\\exercise\\我的文件复制案例副本.txt");
       /*文件输出字节缓冲流*/
       BufferedOutputStream bfou=new BufferedOutputStream(fou);
       byte [] buffer=new byte[1024];//自定义缓冲区
       int len=0;
       while((len=bfin.read(buffer))!=-1){//读取数据
        bfou.write(buffer,0,len);//写出数据
       }
       bfin.close();
       bfou.close();
       fin.close();
       fou.close();
 }
 public  static void copy_2() throws IOException{
  /*由字符缓冲流处理的输入流*/
  BufferedReader bfr=new BufferedReader(new FileReader("E:\\code\\Java\\practice.java\\src\\exercise\\我的文件复制案例副本.txt"));
  /*由字符缓冲流处理的输出流*/
  BufferedWriter bfw=new BufferedWriter(new FileWriter("E:\\code\\Java\\practice.java\\src\\exercise\\我的文件复制案例副本2.txt"));
  int t;
  char c;
  while((t=(char)bfr.read())!=0xffff){//读取数据
   c=(char)t;
   bfw.write(c);//写出数据
  }
  bfr.close();
  bfw.close();//关闭流
 }
}

 

照片名称：8-6-1


照片名称：8-6--1

----------------------------------------------------------------------------------------------------
/**功能：某人在玩游戏的时候输入密码为123456后成功进入游戏（输入超过五次 则被强行退出）要求用程序实
 * 现密码验证的过程:
 * 思路：1：从键盘读取数据用并用缓冲流处理
 *     2：从内存读出数据流，并用缓冲流处理
 *     3：读出过程进行判断，如果为123456则输出提示，如果超过五次错误，关闭。
 */
package exercise;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Chapter8_6_2{
 public static void main(String[] args) throws IOException{
  processTestCode();
 }
 public static void processTestCode() throws IOException{
  System.out.println("请输入游戏密码：");
  BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in ));
  BufferedWriter bfw=new BufferedWriter(new OutputStreamWriter(System.out));
  String line=null;
  for(int i=0;i<5;i++){
   if("123456".equals(line=bfr.readLine())){
    System.out.println("欢迎进入游戏界面！！！");
    break;
   }else if(i!=4){
    System.out.println("密码错误您还有"+(4-i)+"次机会：");
   }
   else if(i==4){
    System.out.println("系统检测到您输入多次有误，请尝试找回密码!!!!");
    System.exit(0);
   }
   
   
  }
  
 }
}
照片名称：8-6-2
--------------------------------------------------------------------------------------------------

第九章

/**功能：编写一个JFrame窗口，要求如下
 * 1：在窗口的最上方放一个JLable标签，标签中默认的文本是“此处显示鼠标右键点击的坐标”
 * 2：位JFrame添加一个鼠标事件，当鼠标右键点击窗口时，鼠标的坐标在JLable标签中显示。
 */
package exercise;
import java.awt.FlowLayout;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.JLabel;
 public class Chapter9_6_1{
  public static void main(String[] args){
  MyJFrame mj=new MyJFrame();//定义窗口框架类
  mj.lunchframe();//调用框架类的lunchframe方法
  }
 }
class MyJFrame extends JFrame{//通过继承JFrame的方法来实现一个窗口
 JLabel jb=new JLabel("此处显示鼠标右键点击的内容");//定义一个标签并初始化其默认文本
 public void lunchframe(){
  setLocation(300,500);//设置窗体的位置
  setSize(400,400);//设置窗体的大小
  setTitle("郝芳的第九章课后习题1");
  setLayout(new FlowLayout(150));//设置窗体的布局管理器
  addWindowListener(new WindowAdapter() {//为窗体添加一个关闭窗体的事件监听器
  public void windowClosing(WindowEvent e) {//实现窗体适配器中的一个方法
    super.windowClosing(e);//调用父类的关闭方法
   }
  });
  setVisible(true);//使窗体为可见
  add(jb);//窗体上添加标签
  jb.addMouseListener(new MyMouseListener());//标签上注册一个鼠标事件监听
 }
 class MyMouseListener extends MouseAdapter{//自定义一个事件监听，继承自事件体系-适配器
  public void mousePressed(MouseEvent e) {//重写鼠标的点击事件
   if(e.getButton()==MouseEvent.BUTTON3){//如果是鼠标右键则执行以下操作
   int x=e.getX();//获取鼠标的x坐标
   int y=e.getY();
   String s="当前鼠标坐标为"+x+","+y;
   jb.setText(s);//重置标签的内容
   }
  }
  
 }
 
 
}
照片名称：9-6-1
------------------------------------------------------------------------------------------
/**功能：编写一个JFrame窗口，要求如下，
 * 1；在窗口中的NORTH区域放置一个JPane面板，
 * 2：在此面板中从左到右依次放置如下组件，
 *   JLable标签，标签的文本为“兴趣”
 *   3个JCheckBox多选按钮，文本分别为“羽毛球”“乒乓球”“唱歌”
 *   JLable标签，标签的文本为“性别”
 *   2个JRadioButton按钮，文本为男，女
 * 3：窗口的CENTER区域放置一个JScrollPane容器，容器中放置一个JTextArea文本域
 * 4：当点击多选按钮和单选按钮时，会把选中按钮的文本显示在JTextArea文本域中
 */
package exercise;
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class Chapter9_6_2{
 public static void main(String [] args){
  MyJFrame2 mjf2=new MyJFrame2();
  Thread  thread1=new Thread(mjf2);
  thread1.start();
  
 }
}
class MyJFrame2 extends JFrame implements Runnable{
 JPanel jp=new JPanel(new FlowLayout(80));//定义一个面板并把它的布局设置出来
 JLabel jb1=new JLabel("兴趣");//定义两个标签
 JLabel jb2=new JLabel("性别");
 JCheckBox jcb1=new JCheckBox("羽毛球");//定义三个复选框
 JCheckBox jcb2=new JCheckBox("乒乓球");
 JCheckBox jcb3=new JCheckBox("唱歌");
 JRadioButton jrb1=new JRadioButton("男");//定义两个单选按钮
 JRadioButton jrb2=new JRadioButton("女");
 JScrollPane jsp=new JScrollPane();//定义一个可以加滚动条的容器面板
 JTextArea jta=new JTextArea();//定义一个文本区域
 public void run(){
  setLocation(400,500);//设置窗体的位置
  setTitle("郝芳的第九章课后习题2");
  addWindowListener(new WindowAdapter() {//为窗体添加一个关闭窗体的事件监听器
  public void windowClosing(WindowEvent e) {//实现窗体适配器中的一个方法
    System.exit(0);
   }
  });
  add(jp,BorderLayout.NORTH);//添加面板
  jp.add(jb1);//添加标签
  jp.add(jcb1);//添加复选框
  jcb1.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
    if(jcb1.isSelected()){
    jta.append("羽毛球");
    }
    
   }});//为复选框添加事件监听
  jp.add(jcb2);
  jcb2.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
    if(jcb2.isSelected()){
    jta.append("乒乓球");
    }
    
   }});
  
  jp.add(jcb3);
  jcb3.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
    if(jcb3.isSelected()){
    jta.append("唱歌");
    }
    
   }});
  
  jp.add(jb2);//添加第二个标签
  jp.add(jrb1);//添加单选按钮
  jrb1.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
    if(jrb1.isSelected()){
    jta.append("男");
    }
    
   }});//为单选按钮添加事件监听
  
  jp.add(jrb2);//添加单选按钮
  jrb2.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
    if(jrb2.isSelected()){
    jta.append("女");
    }
    
   }});
  add(jsp,BorderLayout.CENTER);
  //设置滚动条
   jta.setColumns(20);       
   jta.setRows(5);      
   jsp.setViewportView(jta);       
   getContentPane().add(jsp, java.awt.BorderLayout.CENTER);     
   pack();
  setVisible(true);//使窗体为可见
 }
 

} 

照片名称：9-6-2
-------------------------------------------------------------------------------------------------------
/**功能：编写一个JFrame窗口，要求如下：
 * 1：窗口包含一个菜单栏和一个标签。
 * 2：菜单栏中有两个菜单，第一个菜单有两个菜单项，他们之间用分隔符分开，第二个菜单有一个菜单项。
 * 3：JLabel标签放置在窗口的中间，当点击菜单时，菜单项中的文本显示在JLabel标签中。
 */
package exercise;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.*;
public class Chapter9_6_3{
 public static void main(String[] args){
  MyJFrame3 mjf3=new MyJFrame3();//定义一个任务
  Thread  thread1=new Thread(mjf3);//将任务封装到线程内
  thread1.start();//开启线程 
 }
}
class MyJFrame3 extends JFrame implements Runnable{
 JMenuBar jmb=new JMenuBar();
 JLabel jb=new JLabel();
 JMenu jm1=new JMenu("文件");
 JMenu jm2=new JMenu("编辑");
 JMenuItem jmi1=new JMenuItem("新建");
 JMenuItem jmi2=new JMenuItem("保存");
 JMenuItem jmi3=new JMenuItem("复制");
 
 
 public void run(){
  setLocation(400,500);//设置窗体的位置
  setSize(400,400);
  setTitle("郝芳的第九章课后习题3");//设置标签
  addWindowListener(new WindowAdapter() {//为窗体添加一个关闭窗体的事件监听器
  public void windowClosing(WindowEvent e) {//实现窗体适配器中的一个方法
    System.exit(0);
   }
  });
  setJMenuBar(jmb);//添加菜单栏
  jmb.add(jm1);//添加文件菜单
  jm1.add(jmi1);//添加菜单项
  jmi1.addActionListener(new ActionListener(){//添加事件监听
   public void actionPerformed(ActionEvent e) {
    jb.setText("新建");  
   }
   
  });
  jm1.addSeparator();
  jm1.add(jmi2);//添加菜单项
  jmi2.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
    jb.setText("");
    jb.setText("保存");  
   }
   
  });
  jmb.add(jm2);//添加编辑菜单
  jm2.add(jmi3);//添加菜单项
  jmi3.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
    jb.setText("");
    jb.setText("复制");  
   }
   
  });
  add(jb,BorderLayout.CENTER);
  //pack();
  setVisible(true);//使窗体为可见
 }
 
}

照片名称：9-6-3
------------------------------------------------------------------------------------------------

第十章

/**功能：使用InetAddress类获取本地计算机的IP地址和主机名，甲骨文公司(www.oracle.com)主机的IP地址。
 * */
package exercise;
import java.net.*;
public class Chapter10_5_1{
 public static void main(String[] args) throws Exception{
  InetAddress i=InetAddress.getLocalHost();
  System.out.println("address:"+i.getHostAddress());//打印本地IP地址
     System.out.println("name:"+i.getHostName());//打印本地主机名
     InetAddress o=InetAddress.getByName("www.oracle.com");//获取oracle公司的ip
     System.out.println("address:"+o.getHostAddress());
     System.out.println("name:"+o.getHostName());
 }
}

照片名称：10_5_1
------------------------------------------------------------------------------------------------------
/**功能：使用UDP协议编写一个网络程序，设置接受端程序监听端口为8001，发送端发送的数据是“hello word”*/
package exercise;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class Chapter10_5_2_send{
 public static void main(String[] args) throws IOException{
  System.out.println("发送端启动......");
  DatagramSocket ds = new DatagramSocket(8888);//创建套接字
  byte[] buf=(new String("hello word")).getBytes();
  DatagramPacket dp =
   new DatagramPacket(buf,buf.length,new InetSocketAddress("127.0.0.1", 8001));
        ds.send(dp);//发送
        ds.close();//，关闭资源
  }
  
  
  
  
 }
 

--------------------
package exercise;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Chapter10_5_2_rece{
 public static void main(String[] args) throws IOException{
  System.out.println("接受端启动......");
  //1,建立udp socket服务。
  DatagramSocket ds = new DatagramSocket(8001);
     //定义技术数据的包
  byte[] buf = new byte[1024];
  DatagramPacket dp = new DatagramPacket(buf,buf.length);//创建一个数据包
     while(true){

   ds.receive(dp);//阻塞式的。接收数据
   System.out.println(new String(buf,0,dp.getLength()));
    
    
    } 
   }
 }

照片名称：Chapter10_5_2
-------------------------------------------------------------------------------------------------------
 /**功能：使用TCP协议编写一个网络程序，设置服务器程序监听端口为8002，当与客户端建立连接以后，向客户端
 * 发送"hello word"客户端负责将信息输出。
 */
package exercise;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
public class Chapter10_5_3_Client{
 public static void main(String[] args)throws Exception{
  System.out.println("客户端已启动");
  Socket sc=new Socket("127.0.0.1",8002);//定义客户端套接字
  OutputStream os=sc.getOutputStream();//启动客户端的输出流
  DataOutputStream dos=new DataOutputStream(os);//定义数据输出流用于处理套接字的输出流
  dos.writeUTF("hello world");//以UTF_8的编码方式将数据发送
  dos.flush();//刷新
  dos.close();//关闭流
  sc.close();
  
 }
}
-------------------------
 /**功能：使用TCP协议编写一个网络程序，设置服务器程序监听端口为8002，当与客户端建立连接以后，向服务端发送"hello
 *  word"服务端负责将信息输出
*此处也可以建立连接后向客户端发送消息，客户端打印，原理相同，只是调用流方向不同而已*/
package exercise;
import java.io.DataInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Chapter10_5_3_Sever{
 public static void main(String[] args)throws Exception {
  System.out.println("服务端已启动");//打印启动信息
  while(true){//由于服务端不断处于监听状态，所以它必须用死循环
   ServerSocket ss=new ServerSocket(8002);//创建服务套接字
   Socket s=ss.accept();//定义服务端的接受套接字
   DataInputStream dis=new DataInputStream(s.getInputStream());//定义服务端的输入数据流
   System.out.println(dis.readUTF());//打印数据流一UTF_8的编码方式
   dis.close();
   ss.close();
  }
 }
}

照片名称：Chapter10_5_3 
------------------------------------------------------------------------------

2-4章 

/**功能：求出100以内奇数之和
 *思路：1：遍历100以内的所有数
 *    2：判断是否为奇数，是则累加
 **/
package exercise;
public class Chapter2_6_1{
    public static void main(String[] args){
       int sum=0;//存储和的变量
     for(int i=0;i<100;i++){
      if(i%2!=0)sum+=i;//判断
     }
     System.out.println("100以内的奇数之和为："+sum);
    }
}
-----------------------------------------------------------------------
/**功能：已知函数：当x>0时y的值为1+3；当x=0时y的值为0;当x>0时y的值为x^2-1.写一个实现该函数的方法*/
package exercise;

import java.util.Scanner;

public class Chapter2_6_2{
 public static void main(String[] args){
 
  System.out.println("请输入你喜欢的数");
  Scanner scanner=new Scanner(System.in);
  int x=scanner.nextInt();
        int y=fun(x);
        System.out.println("所输入的数经函数之后的结果为："+y);
  
 }
 public static int fun (int   x){
  if(x==0)
   x=0;
     else if(x>0)
      x=x+3;
  else if(x<0)
   x= x*x-1;
   
  return x;
  
  
  
  
 }
}
-----------------------------------------------
/**功能：实现对数组{24,25,12,76,101,96,28}*/
package exercise;
public class Chapter2_6_3{
 public static void main(String[] args){
  int [] a={24,25,12,76,101,96,28};
  bobsort(a);
  for(int i=0;i<a.length-1;i++){
   System.out.println(a[i]);
  }
 }

 private static void bobsort(int[] a) {
  for(int i=0;i<a.length-1;i++){
   for(int j=0;j<i;j++){
    if(a[j]>a[j+1]){
     int temp;
     temp=a[j];
     a[j]=a[j+1];
     a[j+1]=temp;
    }  
   }
  }
   }
}
---------------------------------------------------------
/**
 * 要求：设计一个student类，要求
 *   1：student类中包含姓名，成绩两个属性；
 *   2：分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值；
 *   3；student 类中定义一个无参数的构造方法，和一个接受两个参数的构造方法，两个参数分别为姓名和成
 * 绩属性赋值。
 *   4：在测试类中创建两个student对象，一个使用无参数的构造方法，然后调用方法给姓名和成绩赋值，另
 * 一个使用有参数的构造方法，在构造方法中给姓名和成绩赋值；
 */
package exercise;
class Student {
 String name;
 int grade;
 Student(){//无参数构造器
  System.out.println("恭喜你,创建对象成功");
 }
 Student(String name,int grade){//初始化姓名和成绩的构造器
  this();
  this.name=name;
  this.grade=grade;
 }
 public  void setname(String name){//设置姓名
  this.name=name;
  
 }
 public void setgrade(int  grade){//设置成绩
  this.grade=grade;
  
 }
 public void getname(){//获取姓名
  System.out.println("姓名为："+this.name);
 }
 public void getgrade(){//获取成绩
  System.out.println("成绩为："+this.grade);
 }
}
public class Chapter3_6_1{
 public static void main(String[] args){
  Student s1=new Student();
  s1.setname("张三");
  s1.setgrade(57);
  s1.getname();
  s1.getgrade();
  Student s2=new Student("李四",60);
  s2.getname();
  s2.getgrade();
 }
}
------------------------------------------------------
/**
 * 要求：定义一个father类和一个child类，要求
 *   1：father类为外部类，类中定义一个私有的string类型的属性，name，name的值为zhangjun；
 *   2：child类为father类的内部类，其中定义一个introfather（）方法，方法中定义father的name属性
 *   3：定义一个测试的taste类，在其主函数的方法中创建child对象，并调用其方法；
 */
package exercise;
class Father{
 private String name;
 class Child{
   void introfather(){
   name="zhangjun";
   System.out.println("father的name属性为："+name);
  }
 }
}
public class Chapter3_6_2{
 public static void main(String [] args){
  Father.Child child=new Father().new Child();//创建内部类对象
  child.introfather();//内部类实例调用其方法
 }
}
----------------------------------------------------------------------
/**功能：设计一个学生类和它的子类，Undergraduate
   要求：1：Student类有name 和 age 属性，一个包含两个参数的构造方法，用于给name和age两个属性赋值一个show方法用于打印学生的属性信息。
         2：本科生类还有一个degree属性，有一个包含三个参数的构造方法，前两个用于给name和age赋值，第三个给degree专业赋值，一个show方法用于打印Ungergraduate学生的属性信息
         3:在测试类中分别创建Student类和Undergraduate对象，调用他们的show方法。*/
package exercise;
public class Chapter4_6_1{
 public static void main(String[] args){
  Students s=new Students("张三",20);
  s.show();
  Undergraduate us=new Undergraduate("李四",22,"本");
  us.show();
 }
}
/*学生类，具有学生初始化姓名，年龄以及显示其姓名，年龄的方法*/
class Students{
 String name;
 int age;
 Students(String name,int age){
  this.name=name;
  this.age=age;
 }
 public void show(){
  System.out.println("名字："+name+"......"+"年龄："+age);
 }
}
/*本科生类，继承自学生类，除学生类所具有的功能外，还具有初始化学历，打印学历的功能*/
class Undergraduate extends Students{
 String name;
 int age;
 private String degree;
 Undergraduate(String name,int age,String degree){
  super(name,age);
  this.degree=degree;
 }
 public void show(){
  super.show();
  System.out.println("学位："+degree);
 }
}
-----------------------------------------------------------
/**功能：设计一个Shape 接口和他的两个实现类Square和Circle
    要求1：Shape 接口中有一个抽象方法，area(),方法接收一个double类型的参数，返回一个double类型的结果。
  要求2：Square和Circle中实现了Shape接口，的area（）方法，分别求正方形和圆形的面积并返回。
   在测试类中创建Square 和Circle对象，计算边长为2的正方形和边长为3的圆形的面积。*/
package exercise;
public class Chapter4_6_2{
 public static void main(String [] args){
  Square s=new Square();
  System.out.println(s.area(4.0));
  Circle c=new Circle();
  System.out.println(c.area(2.0));
 }
}
interface Shape{//定义的一个图形接口
 
 public  abstract double area(double a);//接口中有一个求面积的抽象方法
}
class Square implements Shape{//正方形实现了图形接口
 public double area(double a){
  return a*a;
 }
}
class Circle implements Shape{//圆实现了图形接口
 public static final double PI=3.1415926;
 public double area(double r){
  return PI*r*r;
 }
}
--------------------------------------------
/**功能：自定义一个异常类，NoThisSoundException和player类，在Player的play（）方法中使用自定义异常类
   要求：NoThisSoundException继承自Exception类，类中有一个无参和接受一个参数的构造方法，构造方法中使用super关键字调用父类的构造方法，
           2：player类中定义一个play(int index)方法，方法接受一个int型的参数，表示播放歌曲的索引，当index>10时，play方法用throw关键字抛出NoThisSongException异常，创建异常对象时，调用有参的构造方法，传入“您播放的歌曲不存在”
         3：在测试类中创建player对象，并调用play（）方法测试自定义的NoThisSongException，使用try....catch语句捕获异常，调用NoThisSongException的getMessage()方法打印出异常信息。*/
package exercise;
import java.lang.*;
public class Chapter4_6_3{
 public static void main(String [] args){
  Player p=new Player();//测试类中创建一个对象。
  try{
   p.play(11);//调用对象方法的时候捕获异常
  }catch(NoThisSoundException e){
   System.out.println(e.getMessage());//将捕获到的异常进行处理并打印相关信息
  }
 }
}   
class NoThisSoundException extends Exception{//自定义一个类，继承自exception
 NoThisSoundException(){//定义一个无参的构造方法
  super();
 }
 NoThisSoundException(String Message){//有参的构造方法
  super(Message);
  
 }
}
class Player{//定义一个Player类，
 int index;
 public void play(int index)throws NoThisSoundException{//在方法中声明异常
  if(index>10) throw new NoThisSoundException("您播放的歌曲不存在");//发生异常时抛出异常
 }
}