我看下面有个人问道了，接口new 实现类。回答的是运用多态，多态的三个必要条件是继承，重写，父类引用指向子类对象。我对这个有点疑问。是不是接口就可以看作是类似继承呢？然后实现接口是类似重写，接口new 实现类是父类引用指向子类对象

这是我在网上搜到的解答，是不是我们平时学的所谓的继承是第一个实现继承。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

我是是不是可以理解为，装饰器模式是前面讲的组合和继承的综合应用。

老师，

fis.read(buf) 这句代表什么，这里面的buf是数组，放在read里面是指什么，能得到什么？

老师我想问一个问题，就是我学习流循环把他和实际应用结合起来。就是我想了解一下，打印流以及数据流和对象流在实际应用中都有哪些体现的地方或者说是应用的方向。我理解的不太透彻这几个，所以就不把我认为的说出来了，希望老师给我解答，验证我想的是否正确。

反射获取Class对象，视频只讲了三种方式，还有种方式是ClassLoader 类加载器来实现的，将class装进内存中，这个内存指的是JVM哪一块？ClassLoader 类加载器的运行原理机制又是什么

绝对路径是换了，但是又显示这样的错误

文件名应该没错啊

<?xml version="1.0" encoding="UTF-8"?>
<books xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:niNamespaceSchemaLocation="{book.xsd}">
    <book id ="1001">
        <name>java开发实战</name>
        <author>张小三</author>
        <price>98.5</price>>
    </book>>
</books>

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="books">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="book" maxOccurs="unbounded">
                    <xs:complexType>
                        <xs:sequence>
                        <xs:element name="name" type="xs:string"></xs:element>
                        <xs:element name="author" type="xs:string"></xs:element>
                        <xs:element name="price" type="xs:double"></xs:element>
                        </xs:sequence>
                        <xs:attribute name="id" type="xs:positiveInteger" use="required"></xs:attribute>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

package com.Jin.XML;

import org.xml.sax.SAXException;

import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws SAXException {
        //(1)创建SchemaFactory工厂
        SchemaFactory sch = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
        //(2)建立验证文件对象
        File schemaFile = new File("book.xsd");
        //(3)利用SchemaFactory工厂对象，接收验证的文件对象，生成Schema对象
        Schema schema = sch.newSchema(schemaFile);
        //(4)产生对此schema的验证器
        Validator validator = schema.newValidator();
        //(5)要验证的数据（准备数据源）
        Source source = new StreamSource("book.xml");
        //(6)开始验证
        try{
            validator.validate(source);
            System.out.println("成功");
        }catch (IOException e) {
            e.printStackTrace();
            System.out.println("失败");
        }

    }
}

显示找不到文件

我看了之前过相同问题的，老师你回复idea要用绝对路径，我找了很久也不知道怎么弄，能说的仔细点吗

多线程问题：以下代码通过run方法和start方法输出的结果都是一样，这个有和区别？调用run方法是单线程，调用start是多线程吗？

public class MyThread extends Thread{
    public void run(){
        //线程体
        System.out.println("My Thread------------------");
    }
}

public class TestMyThread {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.run();
        myThread.start();
        System.out.println("---------Main");
    }
}

老师有个空指针求看

视频末尾的hashset对象迭代遍历的时候，为什么不是123，345，456 这个顺序输出。而是456，345，123这样的顺序输出？

关于文件读取设定中转站，老师大小都是设定1024，这个大小对于读取大文件或者较多文件时，是否足够用，若设定更大的空间，是否可用提高效率

byte[] buf=new byte[1024];

package com.Jin.server;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Test {
    public static void main(String[] args) throws IOException {
        System.out.println("__________服务器已启动______________");
        //(1)创建ServerSocket对象
        ServerSocket server = new ServerSocket(9999);
        //(2)监听是否有客户端来请求连接
        Socket client = server.accept();
        //(3)获取输入流
        InputStream is = client.getInputStream();
        System.out.println((char)is.read());
        //(4)获取输出流
        //“收到了”
        OutputStream os = client.getOutputStream();
        os.write("收到了！".getBytes());
        //(5)关闭流，关闭Socket
        if (os!=null){
            os.close();
        }
        if (is!=null){
            is.close();
        }
        if (client!=null){
            client.close();
        }
    }
}



package com.Jin.client;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class Test {
    public static void main(String[] args) throws IOException {
        //(1)创建Socket对象
        Socket client = new Socket("192.168.0.101",9999);
        //(2)获取输出流
        OutputStream os = client.getOutputStream();
        os.write('a');
        //(3)获取输入流
        InputStream is = client.getInputStream();
        byte [] buf = new byte[1024];//中转站
        int len = 0;//读到字节的个数
        while ((len=is.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
        //(4)关闭流
        if (is!=null){
            is.close();
        }
        if (os!=null){
            os.close();
        }
        if (client!=null){
            client.close();
        }

    }

}

启动不了，显示错误

缓冲字节流和缓冲字符流问题

老师，我在测试缓冲字节流_缓冲字符流时，发现缓冲字节流可以读取复制文本、视频、图片等文件，复制的文件大小一致可以正常打开。缓冲字符流复制视频和图片后，文档变大了，而且无法打开，复制文档后，打开出现乱码情况。

这个是什么原因导致。

import java.io.*;

public class TestCopy2 {
    public static void main(String[] args) {
        BufferedReader br= null;
        BufferedWriter bw= null;
        long start= 0;
        try {
            br = new BufferedReader(new FileReader("G:\\1.txt"));
            bw = new BufferedWriter(new FileWriter("F:\\1.txt"));
            start = System.currentTimeMillis();
            String line=null;
            while((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end=System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));

    }
}

try catch 和抛出异常的疑问：

以下2段代码，都能往磁盘写文件，在处理异常时，用try catch和抛出异常都能正常写文件，2者在用法上有什么规则或者要求吗？抛出异常感觉代码会更简洁，

import java.io.FileWriter;
import java.io.IOException;
public class TestFileWrite2 {
    public static void main(String[] args) throws IOException {
        FileWriter writer=new FileWriter("G:\\test5.txt");
        writer.write("hello,python");
        if(writer!=null) {
            writer.close();
        }
    }
}

-------------------

import java.io.IOException;
public class TestFileWriter {
    public static void main(String[] args) {
        //创建对象
        FileWriter writer=null;
        try {
            writer=new FileWriter("G:\\test2.txt");
            //写数据
            writer.write("hello,java");//写到的是缓冲区，不关闭不会写到文件里
            // writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //
            try {
                if(writer!=null)
                writer.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

老师，下面提问里许多人说什么反编译，我看视频里没提呀，他们说的是以前的视频的内容吗