初学JAVA04

网络编程

    网络的两种模型：        OSI 七层结构(标准化的网络模型)            会话层、表示层、应用层                如何在网络已经能够收发数据包的情况下完成网络程序之间的通信            传输层(网络通信软件的基础)                   规定了在能够找到终端之间的通路的情况下，应当如何收发数据包            网络层(网络通信软件的基础)                   规定了一个数据包从网络终端(电脑)发出之后，应通过什么方式寻找路径，从而能够传输到另一网络终端上            数据链路层(相对比较低层)                   规定了在网络中传输时，底层的包结构            物理层(相对比较低层)                   网络连接中的一些电气特性(如网线的电压电阻等等物理参数)        TCP/IP 协议族            应用层                应用程序使用底层的网络服务，典型的应用层协议包括 ftp、 http 协议等            传输层            IP 层            数据链路层            物理层

TCP编程

    TCP 协议是传输层的协议(特点：一个有连接、可靠的协议)        有连接：进行 TCP通信之前，两个需要通信的主机之间要首先建立一条数据通道        可靠：   TCP 协议能够保证数据能够完整无误的传输    端口号：        网络通信的本质，就是进程间通信        通过 IP 地址可以定位某一台电脑，而通过端口号可以找到电脑中某一个的进程        在一台主机中，每个进程端口号上只能绑定唯一的一个进程    基本步骤：        服务器端：            1、 创建 ServerSocket 对象(并绑定端口)                    ServerSocket ss = new ServerSocket(9000);            while(true){        //保证服务器程序不会终止                2、 调用 accept 方法，等待来自客户端的连接                3、 创建并启动新线程进行 I/O 操作(调用 getXXXStream 方法)    //允许多用户同时浏览和访问                4、 关闭 Socket            }        客户端：            1、 创建 Socket 对象，并连接服务器                    Socket s = new Socket("150.236.56.101", 9000);            2、 调用 getXXXStream 方法，进行 I/O            3、 关闭 Socket        服务器端：

UDP编程

    UDP 是一个无连接，不可靠的协议        优点：效率较高            eg：网络语音以及视频聊天应用    基本步骤：        服务器端：            创建一个 DatagramSocket 类型的对象                DatagramSocket socket = new DatagramSocket(9000);            创建一个空数组,接收数据                byte[] buf = new byte[100];            创建一个 DatagramPacket                DatagramPacket paper = new DatagramPacket(buf, 0, buf.length);            调用 socket 对象的 receive 方法接受数据                socket.receive(paper);                可以通过 paper 对象的下面几个方法获得相关信息：                    paper.getSocketAddress() : 获得发送者的地址                    paper.getLength() : 获得发送的数据的长度        客户端：            创建一个 DatagramSocket                DatagramSocket socket = new DatagramSocket();    //系统会自动为客户端分配一个随机的端口号。            准备一个 byte 数组        //保存的就是需要发送的数据内容                String str = "hello server";                byte[] data = str.getBytes();            封装到一个 DatagramPacket 中                   DatagramPacket packet = new DatagramPacket(                    data, 0, data.length,                    new InetSocketAddress("150.236.56.101", 9000)    //表示数据要发送到哪个地址去                    );            调用 socket 的 send 方法，发送 packet 对象                socket.send(packet);

URL编程

    URL:统一资源定位符(Uniform Resource Locator),表示 Internet 上某一资源的地址    URL 的语法格式:        协议名 ://主机名(或者IP地址):端口号/资源路径    基本步骤：        1、 创建 URL 对象        2、 调用 URL 对象的 openConnection 方法，获得 URLConnection        3、 调用 URLConnection 方法的 getInputStream，获得输入流，从而读取资源        4、 I/O 操作        5、 关闭 I/O 流

反射 通用编程 作用：在最大程度上实现代码的通用性

    类对象：java.lang.Class 类的对象    类加载的产物        封装了一个类的所有信息(类名、父类、接口、属性、方法、构造方法等)    获取类对象：        1. 类名.class ： 直接获得某个类的类对象        2. getClass()方法 ： 通过类的对象获得类对象        3. Class.forName()方法 ： 字符串参数，必须带包名            public static Class forName(String className) throws ClassNotFoundException    使用类对象获取类的信息：        getName(): 获得类的名称，包括包名        getSimpleName(): 获得类的名称，不包括包名        getSuperClass(): 获得本类的父类的类对象        getInterfaces() : 获得本类所实现的所有接口的类对象，返回值类型为 Class[]，    使用类对象获取类中方法的信息：        public Method[] getDeclaredMethods() throws SecurityException        public Method[] getMethods() throws SecurityException        getMethods()：返回类中所有的公开方法，包括父类中定义的公开方法。        getDeclaredMethods()：返回在本类的所有方法，包括私有方法    使用类对象创建类的对象：newInstance()        Class c = Student.class;        Student stu = (Student) c.newInstance();

反射包( java.lang.reflect )

    Field 类        一个 Field 对象封装了一个属性的信息        获得 Field 对象:            Field getDeclaredField(String name)                获得本类属性，包括本类的非公开属性            Field getField(String name)                获得本类的公开属性以及从父类继承到的公开属性，但是无法获得非公开属性        修改属性:            public void set(Object obj, Object value)    //(要修改属性的对象,属性值要修改成什么)        获取属性:            public Object get(Object obj)    //要读取哪一个对象的属性        私有属性:            public void setAccessible(boolean flag)    //(true)     --打破封装    Method 类        获取特定方法            public Method getMethod(String name,Class[] parameterTypes)        //(方法名,参数表)            public Method getDeclaredMethod(String name,Class[] parameterTypes)        调用对象的方法            public Object invoke(Object obj, Object[] args)        //(对哪一个对象调用方法,调用方法时的参数表)        私有方法            调用setAccessible(true)     Constructor 类        一个Constructor 对象代表了一个构造函数。        getConstructors() / getDeclaredConstructors()    //获得 Constructor数组/指定的构造方法        调用 Constructor 类中的 newInstance 方法创建对象

标注(Annotation) 描述代码的代码 给机器看

    注释：描述代码的文字    给人看的    标记标注：@标注名    //@Override    单值标注：@标注名(属性名=属性值)    普通标注：@标注名(属性1=值1属性2=值2 ...)    特例：对于单值标注，如果属性名为value，"value="可以省略    //@标注名("Hello")    @Target(value={ElementType.METHOD})    //METHOD只能修饰方法...    @Retention(RetentionPolicy.RUNTIME)    //RUNTIME保留注释...    public @interface Test{        String value() default "默认值";        //标注中，定义属性语法    }

OOAD初步

OOAD：面向对象的分析与设计UML图以及类关系    UML：统一建模语言    使用 UML，能够用图形的方式比较清晰的表达出软件设计师的设计意图            也能够让程序员之间更加容易的交流软件的结构和设计    9 种基本的图形：用例图，类图，对象图，时序图，协作图，组件图，部署图，活动图和状态转换图    类图：描述系统中类的组成，以及类与类之间的关系        UML 表示类:            一个矩形来表示一个类(类名、属性、方法)            -name: String    //先写属性名，后写属性的类型            -age: int        //"-"表示私有,"+"表示公开            +study(hour: int): void    //先写方法名，然后写参数表，最后是返回值类型        继承关系:            子类继承父类，从子类出发，用一个空心的三角箭头指向父类        接口：            接口名：<<interface>>            用一个空心的三角箭头指向被实现的接口，接口和实现类之间用虚线连接            ----------------------------------------------------------------            一个空心的圆形，写上接口名            一根实线连接接口和实现类，表示接口的实现    类关系：        继承关系        依赖关系("use-a"关系)            A 类中有一个 B 类型的局部变量            Person类依赖Boat类，用一根虚线连接两个类，并在被依赖的一方画一个箭头。        关联关系("has-a"关系)            A关联B：A类中有B类的引用(A类中有一个B类型的属性)            1.聚合                外部对象和内部对象在失掉关联关系之后，依然可以分别存在                    eg:人有一辆自行车                在外部对象的一端，用一个空心的菱形表示聚合关系            2.组合                外部对象管理内部对象的生命周期                    eg:人有一双手                在外部对象的一端，用一个实心的菱形表示组合关系            方向性                A 类关联 B 类并不意味着 B 类也关联 A 类。                单向关联                    箭头由 Person 类指向 Bike 类，表示只有 Person 类关联 Bike 类                双向关联(在一方代码中维护关系)                    在 Man 类和 Woman 类之间只有一道实线，没有箭头            多重性                一对一关联(一个人只有一辆自行车、一夫一妻)                一对多关联(一个人有多个地址)                    在单向关联的基础上，在"一"的一段用一个 1 来表示，而在"多"的一段用一个*来表示

常用设计模式

    单例模式(只能创建一个对象)      class Singleton{    //饿汉式(创建对象时机较早)            private Singleton(){}    //私有的构造方法            private static final Singleton instance = new Singleton();    //静态的 instance 属性            public static Singleton getInstance(){    //静态的 getInstance()方法                return instance;            }        }        -------------------------------------------------------------------------      class SingleClass{    //懒汉式(效率低，因为有同步)            private static SingleClass single = null;            private SingleClass(){}            //静态同步方法 对 当前类对象加锁（SingClass.class）            public static synchronized SingleClass newInstance(){    //synchronized                if(single==null){                    single = new SingleClass();                }                return single;            }        }    简单工厂模式(各司其职)        eg：早晨吃煎饼，直接调用卖煎饼的方法，返回煎饼对象

软件的三层体系结构

    需求的变化，导致代码的消亡(代码越改越乱)    开闭原则(软件对扩展开放，对修改关闭)    各司其职    封装    弱耦合性    多态    可重用性    封装    可扩展性    继承    数据访问层(DAO层)    负责数据的增加，删除，修改和查询        数据访问对象(Data Access Object)，简称 DAO    业务逻辑层(biz层)    处理数据        业务对象(Business Object)，简称 BO    显示层(view层)        负责接收用户请求，并显示数据        负责与用户交互的对象称之为View Object，简称 VO。三层结构的 HelloWorld 程序    package dao;    public interface Dao {        //dao层的接口        String getData();    }    package biz;    import dao.Dao;    public interface Biz {        //biz层的接口        void setDao(Dao dao);    //因为biz层需要调用dao层的方法        String dealData();    }    package view;    import biz.Biz;    public interface View {        //view层的接口        void setBiz(Biz biz);    //view需要调用biz层的方法        void showData();    }分层的优势：    当需求发生改变时，我们可以把改变局限在某个层次中，而不影响其他层次。    如果某一个层次的需求发生变化，则我们只需要针对那个特定的层次，修改相应的代码，而不用改变其他层次的代码。    此外由于层是一种弱耦合结构，层与层之间的依赖是向下的，改变上层的设计对于其调用的底层而言没有任何影响。    设计时，应遵循面向接口设计的思想，那么这种向下的依赖也就是一种弱依赖关系。    在不改变接口定义的前提下，理想的分层式架构，应该是一个支持可抽取、可替换的“抽屉”式架构。