客户端文本文件,服务器端将文本文件中的内容复制输出到一个新的文本文件中
服务器端:
Public static void main(String[]args) throws IOException{
SeverSocket ss=newServerSocket(10000);
Socket s=ss.accept();
//获取通道里的流
BufferedReader br=newBufferedReader(new InputStreamReader(s.getInputStream()));
//服务器端要将输出文本文件进行复制
BufferedWriter bw=newBufferedWriter(new FileWriter(“Text.java”));
String line=null;
While((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
bwServer.write("文件复制完了...");
bwServer.newLine();
bwServer.flush();
//关闭资源
bw.close();
s.close();
}
}
客户端文本文件,服务器将文本文件中的内容复制到一个新的文本文件中
Public static void main(String[] args) throws IOException{
Socket s=new Socket(“192.168.10.101”,10000);
//封装文本文件,对于文本文件字符缓冲输入流
BufferedReader br=newBufferReader(new FileReader(“Text.java”));
//封装通道里的字节输出流
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//将Text.java一次读取一行写到通道内的流中
String line=null;
while((line=br.readLine()!=null){
bw.write(line);
bw.newLine();
bw.flush() ;
}
s.shutdownOutput() ;//(推荐使用这种方式)
//读取服务器端的反馈
BufferedReaderbrClinet = new BufferedReader(new InputStreamReader(
s.getInputStream()));
//读数据
String fk =brClinet.readLine() ;
System.out.println(fk);}
}
反射: 反射就是通过获取到该类的字节码文件对象
获取字节码文件对象有几种方式?
1. Object类中的getClass()方法,表示正在运行的那个类:Class类
数据类型的class属性 举例:String.class,Student.class
Class类中的特有方法:forName(StringclassName):获取字节码文件对象
创建一个Person类:
publicstaticvoid main(String[] args) throws ClassNotFoundException {
//第一种
Personps1 = new Person();
Class c1 = ps1.getClass() ;//Person.class字节码
Personps2=new Person();
Class c2 = ps2.getClass();
System.out.println(ps1==ps2);//比较的是空间地址是否相同 false
System.out.println(c1==c2);//比较的是person.class的对象地址 true
//第二种:并且获得person.class字节码文件对象
Class c3 = Person.class ;
System.out.println(c3==c1); //true
//第三种:获取类的字节码文件
//需要类的全路径名称
Class c4 = Class.forName("src.day23.Person") ;//全路径名称
System.out.println(c4==c1);
}
通过反射获取构造方法
public Constructor<?>[]getDeclaredConstructors():获取的是当前字节码文件对象中所有的构造方法
//获取构造器对象:Constructor
//获取单个的构造方法
//public Constructor<T> getConstructor(Class<?>...parameterTypes)
Constructor con = c.getConstructor() ;//获取构造器对象
Object obj = con.newInstance() ;
创建对象: Person p = newPerson("龙哥",21,"西安")
System.out.println(p) ;
反射创建对象
获取person类的字节码文件:
Class c= Class.forName("全路径名称") ;
//通过反射获取指定构造方法:getConstructor(Class...parameterTyps) 参数:参数类型.class
//括号里面为参数类型
Object obj = con.newInstance("",,"") ;//实际参数
通过反射获取成员变量并使用
1) 通过反射获取字节码文件对象
Class c = Class.forName("全路径名称");
2) 获取所有的公共的成员变量public Field[] getFields():所有的公共的可访问的字段,返回的是Field对象数组
3) //获取到这个Field对象之前,还获取构造器对象(通过无参构造创建Person类的实例)
Constructor con =c.getConstructor() ;
//创建构造器实例
//m4.setAccessible(true) ;
取消java语言的访问检查
面向对象设计原则:
单一职责原则;开闭原则;里式替换原则;依赖注入原则;接口分离原则;迪米特原则
静态工厂模式(简单工厂):需要提供一个工厂类:让其产生对象
特点:构造方法私有化,外界不能直接创建它的对象
提供静态功能,每一种静态都会产生所需要的对象...
缺点:不利于后期维护
如果添加新的对象,需要创建它的类还需要在静态工厂类提供一些功能!
Eg:
//动物抽象类
public abstract class Animal {
publicabstract void eat() ;
}
public class AnimalDemo {
publicstatic void main(String[] args) {
Animala = AnimalFactory.createAnimal("dog") ;
a.eat();
a= AnimalFactory.createAnimal("cat") ;
a.eat();
//NullPointerException
a= AnimalFactory.createAnimal("pig") ;
if(a!=null){
a.eat();
}else{
System.out.println("目前工厂类没有提供该动物...");
}
}
}
//工厂类:
public class AnimalFactory {
//私有功能
privateAnimalFactory(){
}
public static Animal createAnimal(Stringtype){
if("dog".equals(type)){
returnnew Dog() ;
}elseif("cat".equals(type)){
returnnew Cat() ;
}else{
returnnull ;
}
}
}
//猫的类:
public class Cat extends Animal {
@Override
publicvoid eat() {
System.out.println("猫吃鱼...");
}
}
//狗的类:
public class Dog extends Animal {
@Override
publicvoid eat() {
System.out.println("狗吃肉...");
}
}
工厂方法:每一个动物提供具体的工厂类来产生.并且有一个大的工厂类.
提供一个抽象类,每个动物具体类和接口.
抽象方法的返回值是该抽象类.
针对每个具体动物提供了对应的工厂类à实现该接口à返回值就是需要的具体动物对象.
Eg: public interface Factory {
//就是用来提供常见具体动物的功能
publicabstract Animal createAnimal() ;
}
public class DogFactory implements Factory{
@Override
publicAnimal createAnimal() {
returnnew Dog() ;
}
}
单例模式:
分为饿汉式:一个类加载的时候就会创建一个对象
1. 要将类的无参构造私有化
2. 在成员变量创建该类的实例
3. 提供公共的访问方法
懒汉式:不是加载类就直接创建对象,在需要时创建对象
1. 懒汉式要注意延迟加载.
2. 线程的安全问题
饿汉式:
Public class Student(){
Private Student(){
}
Private static Student s=new Student();//创建该类的实例
public static Student getStudent(){
return s;
}
}
懒汉式:
Public class Teacher {
Private Teacher(){
}
//在成员变量位置声明变量
Private static Teacher t=null;
Public synchronized static Teacher getTeacher(){
If(t=null){
T=new Teacher();
}
Return t;
}
}
装饰者模式:
1. 定义一个接口 2.一个接口的子实现类
3. 创建一个子实现类(修饰)实现接口
4. 需要添加的修饰类继承自子实现类的修饰类,在里面添加方法 并且有一个有参构造
Public interface Phone{}
publicabstract void call() ; //抽象类方法
}
public class IPhone implements Phone {
@Override //实现接口的方法
publicvoid call() {
System.out.println("手机可以电话了....");
}
}
public abstract class PhoneDecorateimplements Phone {
privatePhone p ;
public PhoneDecorate(Phone p){//有参构造 创建的对象为当前对象
this.p= p ;
}
@Override
publicvoid call() {
this.p.call(); //重写call方法
}
}
枚举:
Eg:
Public enum Direction{
FRONGT,BEHIND,LEFT,RIGHT;
}
Public enum Direction1{
FRONG(“前”),BEHIND(“后”),LEFT(“左”),RIGHT(“右”);
Private String name;
Private Direction2(String name){
This.name=name;
}
Public String getName(){
Return name;
}
}
//具体实现
Eg:
public enum Direction3 {
FRONG("前"){
@Override
publicvoid show() {
System.out.println("前");
}
}
//私有化有参构造
//getName方法
//抽象方法
Public abstract void show();
}
//测试类
public static void main(String[] args) {
Directiond = Direction.FRONGT ;
System.out.println(d); //输出的结果为FRONGT
Direction2 d2 = Direction2.BEHIND ;
System.out.println(d2); //BEHIND
String name = d2.getName() ;
System.out.println(name); //后
Direction3 dd = Direction3.RIGHT ;
System.out.println(dd.getName() ); //右
dd.show(); //右
}