反射机制/Java两大开发原则

客户端文本文件,服务器端将文本文件中的内容复制输出到一个新的文本文件中

 

服务器端:

 

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();                            //右

}