/**功能：通过继承Thread类的方式创建两个线程，在Thread线程中指定线程的名称并将这两个线程的名字打印出来*/
import java.lang.T
public class Chapter5_6_1{
public static void main(String [] args){
&MyThread t1=new MyThread(&我的自定义线程&);
&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*/
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：利用测试类测试*/
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--);
照片名称：5-6-3
---------------------------------------------------------------------------------------------------------
/**功能：编写10个线程，第一个线程从1加到10，第二个线程从11加到20......第十个线程从从91加到100，最后把十个线程的结果相加
&分析：根据题可以分析出该题为十个线程，执行十个任务，然后将是个人物累加共享一个数据资源；
&思路：是个线程十个任务，就是创建十个线程，将任务封装到十个线程内部。用一个变量记下每个线程累加的数，然后将该变量累加到共享数据上即可*/
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&//定义一个可以记录每个线程起始累加数的变量
&private static Object obj=new Object();//定义一个锁，用于将来十个现成完成共享数据的累加时的互斥
&public void init(int num){//用来初始化每个线程初始累加数
&&this.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+=//共享数据的累加
照片名称：5-6-4
-------------------------------------------------------------------------------------------------
/**功能：编写一个程序，实现字符串的大小写转换并倒序输出要求如下
&& 1：使用for循环将字符串hello world 从最后一个字符开始遍历。
&& 2：遍历的当前字符如果是大写字符，就使用toLowerCase()方法将其转换为小写字符，反之，将其
&& 则使用toUpperCase()方法将其转换为大写字符
&& 3：定义一个StringBuffer对象，调用append（）方法一次添加遍历的字符，最后调用StringBuffer
&& 的toString()方法，并将得到的结果输出。*/
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对象实例化*/
import java.text.DateF
import java.util.C
import java.util.D
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之间的随机数。
import java.util.R
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遍历该集合。*/
import java.util.ArrayL
import java.util.I
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:要根据自己的要求添加是否相同的对象就需要重写这两个方法 */
import java.util.HashS
import java.util.C
import java.util.I
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类
&public Person(String name, int age) {//person类的构造方法
&&this.name =
&&this.age =
&/*获取和设置姓名年龄的方法*/
& String getName() {
& void setName(String name) {
&&&this.name =
& int getAge() {
& void setAge(int age) {
&&&this.age =
&public int hashCode() {//重写hashCode（）方法。
&&return this.name.hashCode();//Object方法的hashCode返回的是系统分配的哈希值，此处自定义
&public boolean equals(Object obj) {
&&Person p=(Person)
&&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：存取元素按容器的操作方法来操作*/
import java.util.Map.E
import java.util.TreeM
import java.util.M
import java.util.I
import java.util.S
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{
&Students(int snum,String name){
&&this.name=
&&this.snum=
&int getSnum() {
&void setSnum(int snum) {
&&this.snum =
&String getName() {
&void setName(String name) {
&&this.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。
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&));
&&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则输出提示，如果超过五次错误，关闭。
import java.io.BufferedR
import java.io.BufferedW
import java.io.IOE
import java.io.InputStreamR
import java.io.OutputStreamW
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=
&&for(int i=0;i&5;i++){
&&&if(&123456&.equals(line=bfr.readLine())){
&&&&System.out.println(&欢迎进入游戏界面！！！&);
&&&}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标签中显示。
import java.awt.FlowL
import java.awt.event.MouseA
import java.awt.event.MouseE
import java.awt.event.WindowA
import java.awt.event.WindowE
import javax.swing.JF
import javax.swing.JL
&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文本域中
import java.awt.BorderL
import java.awt.FlowL
import java.awt.event.ActionE
import java.awt.event.ActionL
import java.awt.event.ItemE
import java.awt.event.ItemL
import java.awt.event.WindowA
import java.awt.event.WindowE
import javax.swing.JCheckB
import javax.swing.JF
import javax.swing.JL
import javax.swing.JP
import javax.swing.JRadioB
import javax.swing.JScrollP
import javax.swing.JTextA
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标签中。
import java.awt.BorderL
import java.awt.event.ActionE
import java.awt.event.ActionL
import java.awt.event.WindowA
import java.awt.event.WindowE
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地址和主机名，甲骨文公司()主机的IP地址。
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(&&);//获取oracle公司的ip
&&&& System.out.println(&address:&+o.getHostAddress());
&&&& System.out.println(&name:&+o.getHostName());
照片名称：10_5_1
------------------------------------------------------------------------------------------------------
/**功能：使用UDP协议编写一个网络程序，设置接受端程序监听端口为8001，发送端发送的数据是“hello word”*/
import java.io.IOE
import java.net.DatagramP
import java.net.DatagramS
import java.net.InetSocketA
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();//，关闭资源
--------------------
import java.io.IOE
import java.net.DatagramP
import java.net.DatagramS
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&客户端负责将信息输出。
import java.io.DataOutputS
import java.io.OutputS
import java.net.S
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&服务端负责将信息输出
*此处也可以建立连接后向客户端发送消息，客户端打印，原理相同，只是调用流方向不同而已*/
import java.io.DataInputS
import java.net.ServerS
import java.net.S
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&
------------------------------------------------------------------------------
/**功能：求出100以内奇数之和
&*思路：1：遍历100以内的所有数
&*&&&&2：判断是否为奇数，是则累加
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.写一个实现该函数的方法*/
import java.util.S
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)
&&&& else if(x&0)
&&&& &x=x+3;
&&else if(x&0)
&&&x= x*x-1;
-----------------------------------------------
/**功能：实现对数组{24,25,12,76,101,96,28}*/
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]){
&&&&&temp=a[j];
&&&&&a[j]=a[j+1];
&&&&&a[j+1]=
---------------------------------------------------------
&* 要求：设计一个student类，要求
&* &&1：student类中包含姓名，成绩两个属性；
&* &&2：分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值；
&* &&3；student 类中定义一个无参数的构造方法，和一个接受两个参数的构造方法，两个参数分别为姓名和成
&* 绩属性赋值。
&* &&4：在测试类中创建两个student对象，一个使用无参数的构造方法，然后调用方法给姓名和成绩赋值，另
&* 一个使用有参数的构造方法，在构造方法中给姓名和成绩赋值；
class Student {
&Student(){//无参数构造器
&&System.out.println(&恭喜你,创建对象成功&);
&Student(String name,int grade){//初始化姓名和成绩的构造器
&&this.name=
&&this.grade=
&public& void setname(String name){//设置姓名
&&this.name=
&public void setgrade(int& grade){//设置成绩
&&this.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对象，并调用其方法；
class Father{
&private S
&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方法。*/
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{
&Students(String name,int age){
&&this.name=
&&this.age=
&public void show(){
&&System.out.println(&名字：&+name+&......&+&年龄：&+age);
/*本科生类，继承自学生类，除学生类所具有的功能外，还具有初始化学历，打印学历的功能*/
class Undergraduate extends Students{
&private S
&Undergraduate(String name,int age,String degree){
&&super(name,age);
&&this.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的圆形的面积。*/
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()方法打印出异常信息。*/
import java.lang.*;
public class Chapter4_6_3{
&public static void main(String [] args){
&&Player p=new Player();//测试类中创建一个对象。
&&&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类，
&public void play(int index)throws NoThisSoundException{//在方法中声明异常
&&if(index&10) throw new NoThisSoundException(&您播放的歌曲不存在&);//发生异常时抛出异常
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1027次
排名：千里之外}