总结：(C和Java混合)UNIX Domain Socket IPC[优秀范文5篇]

第一篇：总结：(C和Java混合)UNIX Domain Socket IPC

总结：（C和Java混合）UNIX Domain Socket IPC

C语言和Java语言的混合其实是一样的，都是分客户端和服务端；

1、C语言的客户端和Java的服务器端

Java服务端代码：

import android.net.LocalServerSocket;

import android.net.LocalSocket;

import android.net.LocalSocketAddress;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

LocalServerSocket mlss = new LocalServerSocket(“/dev/socket/mysocket”);

while(true)

{

LocalSocket mServerSocket = mlss.accept();

if(mServerSocket!= null)

{

InputStream is = mServerSocket.getInputStream();

outputStream out = mServerSokcet.getOutputStream();

is.read(buff);

out.write(buff);

out.flush();

}

}

mlss.close();

C语言客户端代码结构如下：

int mSocketFd = socket(PF_UNIX, SOCK_STREAM, 0);

CHCEK(mSocketFd);

struct sockaddr_un mRemoteSocket;

mRemoteSocket.sun_family = AF_UNIX;//指定协议

strcpy(mRemoteSocket.sun_path, SOCK_PATH);//指定文件

int len = offsetof((struct sockaddr_un*), sun_path)+

strlen(mRemoteSocket.sun_path);

int io_fd= connect(mSocketFd,(struct sockaddr *)mRemoteSocket, len);CHECK(io_fd);

send(io_fd, buff, sizeof(buff), 0);

recev(io_fd, buff, len, 0);

close(io_fd);

2、C语言版服务器和Java语言客户端

int mSocketFd = socket(PF_UNIX, SOCK_STREAM, 0);

CHCEK(mSocketFd);

struct sockaddr_un mServerAddr;

mServerAddr.sun_family = AF_UNIX;//指定协议

strcpy(mServerAddr.sun_path, SOCK_PATH);//指定文件

int len = offsetof((struct sockaddr_un*), sun_path)+

strlen(mServerAddr.sun_path);

int res = bind(mSocketFd ,(struct sockaddr *)&mServerAddr, len);

listen(mSocketFd,16);

int mIOfd;

struct sockaddr_un mClientAddr;

intmClientAddrSockLen = sizeof(mClientAddr);

if((mIOfd = accept(fd,(struct sockaddr *)&mClientAddr , &mClientAddrSockLen))< 0){//在这个地方等待客户端的sendlog(“Failed to accept socket.return:%derr:%sn”, s, strerror(errno));free(qlog_nodes);

exit(ERR_UNSPEC);

}/////mIOfd是一个fd，可以直接用来读写的//从socket中得到消息ret = TEMP_FAILURE_RETRY(recv(mIOfd, &message,sizeof(message), 0));//读取消息，关于TEMP_FAILURE_RETRY，有专门的介绍

if(ret < 0){

close(s);

SLOGE(“Failed to recv message from socket.return: %d err: %sn”, ret, strerror(errno));

return;

}

//向socket中写入数据ret = TEMP_FAILURE_RETRY(send(mIOfd, buffer, sizeof(buffer), 0));//写入消息

if(ret < 0){

log(“Failed to send message from socket.return: %d err: %sn”, ret, strerror(errno));

return;

}

log(“Send %d bytes out”, ret);

//最后要关闭socket

close(mIOfd);

unlink(“bind的文件”);

Java客户端代码结构

//打开一个Socket

mSocket = new LocalSocket();//与服务器建立连接

mSocket.connect(new LocalSocketAddress(DEBUG_CONTROL_SOCKET_PATH, LocalSocketAddress.Namespace.FILESYSTEM));

//读

try {

OutputStream m_Send = mSocket.getOutputStream();//得到当前byte[] buf = new byte[2];buf[0] = FATAL_ERR_FEATURE;

buf[1] = 1;// useless

mSocket.setSendBufferSize(buf.length);

m_Send.write(buf);//写入

m_Send.flush();} catch(Exception e){

Log.e(LOG_TAG, “write socket error”);

ret = false;

}

//写

try {

InputStream in = mSocket.getInputStream();

in.read(mReadBuffer);

} catch(Exception e){

Log.e(LOG_TAG, “read socket exception!”);return false;

}

第二篇：JAVA总结专题

在这忙忙碌碌的这段时间里，经过老师的辅导，迅速的将一点没有学的JAVA基础搞定了！有了基础学习还是好，万事开头难这句话说的太对了，学计算机语言我觉得记忆好的方法就是多打代码，课前预习，课堂上认真听讲，把现学的方法把以前所做的作业用最简便的方法再一次巩固，创新最重要，在后续的学习中，得要加倍努力学习。

其实学java有不懂，要先自己思考。想清楚这句代码是什么意思。为什么要写在这，等等之类的。等你真的搞不明白的时候，就一定要向老师咨询，不要感到有什么丢人的。因为不会是很正常的事。并不是每个人都是天才，一学就会，一学就能运用自如的。学java有一点是非常重要的，就是练习。一段代码要不停的敲，多敲几遍，尤其是自己不熟悉或者不熟练的代码，更要敲。不要感觉到厌烦，其实我感觉敲代码挺好玩的，并不是一件很枯燥的事。

老师平常布置的课后上机练习题一定要做，课后的练习题能够让你把新学到的知识巩固一遍，能够加深记忆，不会让你在以后做题的时候感到没一点思路。

当感觉到不会的时候，千万不要气馁，因为这很正常，现在的学习就是为了培养你有一个逻辑思维，为了以后开发软件的时候有个完整，清晰的思路。

其实，总体来说。学习java很快乐。尤其是当你遇到一道自己不会的题，然后，又通过自己的努力解决了，那时候，那种心情不是用言语来表达的。就好像你遇到一个数学难题，自己解决了之后那种成就感一样。

学java的时候一定要，放松心情，轻轻松松的来学，随时让自己快乐着，这样能够让你能够更快的接受java，千万不要有什么心理负担，因为java的特点之一就是--简单易懂。只要自己努力到了，就一定能够学好java。

学完了JAVA今天我们用项目案例：迷你DVD管理器来巩固了我们所学的所有内容，通过这项目的操练，首先，1、项目用到了会使用顺序、分支、循环、跳转语句编写程序，2、要会使用数组、操作字符串，3、会使用带参的方法；

4、会定义类、创建和使用对象，看到这些脑袋里一片迷茫啊！不知道怎样写，然后想到早写晚写都一样，就照着书上写起来了，到现在还是弄不懂的就是那个对象数组，不知道怎样去理解，抽象的把我抽晕了，有望老师来给我们补补这一章，在实现DVD的业务处理时，计算时差还是不懂，照着书上打了一遍，可还是得不到想要的结果，经过网上的搜寻与老师讲解，现在已略懂一二了，在做完这项目后，真不知道当时是怎样敲出来的，难道这就是所说的灵感！感觉很高兴，现在已习惯了代码报错，其实代码报错是一件值得鼓励的事，因为没有错就觉得自己什么都懂了，在学习中相信每一个人都遇到过挫折吧！但一定要想方法战胜挫折！我的战胜挫折方法就是不懂思考后还不懂就问，懂了以后就笔记本记下当时的解决方案！学习刚开始！后面的路很长，慢慢的去磨炼了！总结完毕！

第三篇：Java总结

Java实验

1.调试HelloWorld程序

2.this,super,get ,set,把课本90页程序4.7中的name改成私有变量

3.继承，重写，父类引用指向子类对象

4.验证数组Arrays类和Collection类

5.编写一个自己的异常类并捕获之。

6.编写一个类，将该类的几个对象装入TreeSet容器中，并将该容器的内容通过输出流写入文件中。

前三章重点

0.java的数据类型：四类八种-（1）布尔类型Boolean;(2)字符类型char;(3)整数byte,short,int,long;(4)浮点类型：float,double;1.面向对象的3个基本特征：封装，继承，多态。

2.构造方法和普通方法的区别：对构造方法而言，它有以下特性---（1）方法名必须与要创建对象的类名相同。（2）不允许声明返回类型，即使声明为void也不被允许。

3.this关键字:是一个引用，this引用指向的是其本身所在方法的当前对象。this的使用方法:(1)调用成员变量；（2）可以用this()调用其他构造函数。

4.java中只对类成员变量进行自动初始化，而方法内部的局部变量在使用前必须手动初始化。

5.static 关键字：可用来修饰类的成员变量和成员方法，需要注意两点--（1）静态方法不能调用类的非静态方法，不能访问类的非静态变量。（2）静态方法和静态变量（非私有的）可以有两种调用方式，一是实例对象调用，二是类名直接调用。

6.类成员访问控制修饰符public、private、default(可不写，即缺省状态)、protected的使用：public-公用的；private-私有的，只在定义它的类内部使用；default-可以被同一包中的类访问；protected-既可以被同一包中的类访问，也可以被不在同一包中的子类访问。

7.方法的重载：指方法名相同，而方法的参数列表不相同。参数列表不同有三层意思：（1）参数类型不同。（2）参数顺序不同。（3）参数个数不同。另外需注意，在同一个类中，当方法名和参数列表都相同时，访问控制修饰符或方法返回类型不相同并不是方法的重载，而且这种情况在java中是不被允许的。

第四五章重点

1.继承：需使用关键字extends.在使用继承时需注意--（1）每个子类只能定义一个超类（父类），即extends后面应且仅应跟一个类名作为该类的父类。（2）父类中的私有属性和私有方法不能被继承。

2.方法的重写：即子类对超类中的方法保持方法名、返回类型和参数列表不变，重写了方法体，使子类和超类完成不同的工作。重写需注意下面几个关键点：（1）超类中的私有方法不能被重写。（2）访问限制符强度由低到高依次是：public、protected、default、private,在重写过程中，如果子类和父类中方法的返回值、方法名及方法的参数列表都相同，这时，要求子类中该方法的访问限制符强度不能超过父类的。即如果父类中为public时，子类也只能为public,而不能是余下的三种。

3.重载（overload）和覆盖（override）的区别：(1)重载—发生在一个类的内部或子类与父类之间，要求方法名相同而参数列表不一样。（2）覆盖—只能发生在继承过程中，要求子类方法的返回类型，方法名和参数列表同父类的都相同，而方法体不一样。

4.构造器的调用顺序：先祖先，再客人，最后自己。

5.多态：指在类继承中子类和父类中可以有同名但意义或实现方式不同的属性和方法。分为：覆盖和重载。多态的优点：因为多态，可以在程序中对类进行扩展，而不需改变那些操作基类接口的方法。

6.动态绑定：指在代码执行期间，判断所引用对象的实际类型，根据其实际类型调用相应方法。动态绑定存在的三个必要条件--（1）要有继承；（2）要有重写（覆盖）；（3）父类引用指向子类对象（向上转型）。

7.Object中常用的方法总结：toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();（呵呵，尽可能记几个，以防老师让咱们列举）注：java中Object类是所有类的父类，即java中所有的类都有上述9种方法。

8.对象的比较：注意关键字instanceof的使用。

9.抽象类：

抽象方法—用关键字abstract修饰的方法，该方法只需方法的声明，而不需方法的实现（即无方法体）。

抽象类——至少包含一个抽象方法的类，也用abstract关键字声明。（注：（1）抽象类中可以有一些具体方法。（2）抽象类不能实例化。（3）子类继承抽象类必须实现其抽象方法。）

10.接口：

（1）可以看成是高度抽象的抽象类，但是接口不是类。

（2）用关键字interface来声明接口，用关键字imlpements来实现接口。

（3）接口不能有具体方法，不能有实例数据，但可以定义常量。

（4）实现接口的非抽象类必须实现接口的所有方法。

（5）每个类可以实现多个接口，这些接口用逗号隔开，同时，一个接口可以被多个类实现。

第六章：重点看一下实验四

1.容器——Collection(接口)和Map（接口）.Collection——Set(接口)和List(接口)。其中，List必须保持元素的特定顺序，常见的实现类有ArrayList和LinkedList；Set不能有重复元素,常见的实现类有HashSet和TreeSet。

Map——一组成对的“键值对”对象，即其元素是成对的对象，常见的实现类有HashMap和TreeMap。

第七章 1.异常类的根类是Throwable类，它的两个直接子类是Error类和Exception类。

2.异常中常用的5个关键字为：try,catch,finally,throw,throws.其中，try和catch:用于捕获异常；finally:无论try块中的异常是否抛出，finally中的代码块总能被执行；throw:抛出异常；throws：声明异常。

3.“未被检查的异常（Unchecked Exceptions）”和“受检查的异常(Checked Exceptions)”——

Unchecked Exceptions :编译器不检查方法是否处理或抛出的异常，即不做处理，编译时不报错。

Checked Exceptions：受编译器检查的异常，即不做处理编译时通不过。

4.常见的几种Checked Exceptions：ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(尽可能的记几个吧，以防不测)第八章

1.流--字节流和字符流；

流--节点流和处理流。

2.所有的输入流都是从抽象类InputStream和Reader继承而来。所有输出流都是从抽象类OutputStream和Writer继承而来。3．字节流：InputStream和OutputStream;字符流：Reader和Writer；

4.节点流：直接与文件等底层打交道，如FileInputStreamFileOutputStreamFileReaderFileWriter.处理流：相当于包装流，套在节点流上，方便数据处理。相关一些用法，具体参考最后一次实验。

第四篇：java总结

调用父类构造方法

 在子类的构造方法中可使用super(argument_list)语句调用父类的构造方法

 如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法

 如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错

1public class Person {

3private String name;

4private int age;private Date birthDate;

7public Person(String name, int age, Date d){ 8this.name = name;

9this.age = age;

10this.birthDate = d;

11}

12public Person(String name, int age){ 13this(name, age, null);

14}

15public Person(String name, Date d){ 16this(name, 30, d);

17}

18public Person(String name){

19this(name, 30);}

21// ……

22}

1public class Student extends Person {

2private String school;

4public Student(String name, int age, String s){ 5super(name, age);

6school = s;

7}

8public Student(String name, String s){

9super(name);

10school = s;

11}

12public Student(String s){ // 编译出错: no super()13school = s;

14}

15}

对象构造和初始化细节

 分配存储空间并进行默认的初始化

 按下述步骤初始化实例变量

1.绑定构造方法参数

2.如有this()调用，则调用相应的重载构造方法，然后跳转到步骤5

3.显式或隐式追溯调用父类的构造方法(Object类除外)

4.进行实例变量的显式初始化操作

5.执行当前构造方法的方法体

==操作符与equals方法

==操作符与equals方法的区别：

 引用类型比较引用；基本类型比较值；

 equals()方法只能比较引用类型，“==”可以比较引用类型及基本类型；

 特例：当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个实例；

 用“==”进行比较时，符号两边的数据类型必须一致(可自动转换的基本数据类型除外)，否则编译出错；

由装箱引发的——Integer比较的来龙去脉

前置知识： 众所周之，java是保留了int，char等基本数据类型的，也就是说int类型的并不是对象，然而有些方法却需要object 类型的变量，所以java使用了装箱机制，我们可一自豪的这样声明一个整型变量：Integer a = new Integer(10);那么整型的a也就是对象了，那这句是什么意思呢：Integer a= 10;java中可以这样声明一个对象吗？当然不是，从jdk1.5后，java实现了自动装箱，也就是自动将Integer a =10 中的int类型的10转化为了 Integer类型。好，有了前面的只是我们且先看一个题目：

Integer a = 127;

Integer b = 127;

Integer c = 128;

Integer d = 128;

System.out.println(a==b);

System.out.println(c==d);

答案是什么呢？ 如果您回答true，false，那么很遗憾的告诉你，哈哈，其实你答对了！！

那我们晕了就相差1的两个数为啥走向了“反目成仇”的地步呢？凭啥127等于127，我128就不等于128呢？且听我慢慢道来，Integer a =127,Integer a=128。

127，128应该不会造成什么差异吧，难道是自动装箱的过程有猫腻？找下源码看看：

private static class IntegerCache {

private IntegerCache(){}

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {

for(int i = 0;i < cache.length;i++)

cache[i] = new Integer(i128);

}

这是用一个for循环对数组cache赋值，cache[255] = new Integer(255-128),也就是newl一个Integer(127),并把引用赋值给cache[255],好了，然后是Integer b= 127,流程基本一样，最后又到了cache[255] = new Integer(255-128),这一句，那我们迷糊了，这不是又new了一个对象127吗，然后把引用赋值给cache[255]，我们比较这两个引用（前面声明a的时候也有一个）,由于是不同的地址，所以肯定不会相等，应该返回false啊！呵呵，这么想你就错了，请注意看for语句给cache[i]初始化的时候外面还一个{}呢，{}前面一个大大的static关键字大咧咧的杵在哪呢，对静态的，那么我们就可以回想下static有什么特性了，只能初始化一次，在对象间共享，也就是不同的对象共享同一个static数据，那么当我们Integer b = 127的时候，并没有new出一个新对象

来，而是共享了a这个对象的引用，记住，他们共享了同一个引用！！，那么我们进行比较a==b时，由于是同一个对象的引用（她们在堆中的地址相同），那当然返回true了！！

然后我们在看Integer c = 128;Integer d = 128;这两句。现在不用我说就应该能明白了吧，当数据不再-128到127之间时，是不执行return

IntegerCache.cache[i + offset];这句的，也就是不会返回一个static的引用，而是执行了return new Integer(i);于是当 Integer d = 128 时，又会重新返回一个引用，两个不同的引用

在做c==d 的比较时当然返回false了！

下面附上本程序的字节码以供喜欢底层的读者参考：

Compiled from “CompareInteger.java”

public class CompareInteger extends java.lang.Object{

public CompareInteger();

Code:

0:aload_0

1:invokespecial#1;//Method java/lang/Object.“”:()V4:return

public static void main(java.lang.String[]);

Code:

0:bipush 127

2:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

5:astore_1

6:bipush 127

8:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

11: astore_2

12: sipush 128

15: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

18: astore_3

19: sipush 128

22: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

25: astore 4

27: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

30: aload_1

31: aload_2

32: if_acmpne39

35: iconst_1

36: goto40

39: iconst_0

40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

46: aload_3

47: aload4

49: if_acmpne56

52: iconst_1

53: goto57

56: iconst_0

57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return

}

评论：呵呵，这么想你就错了，请注意看for语句给cache[i]初始化的时候外面还一个{}呢，{}前面一个大大的static关键字大咧咧的杵在哪呢，对静态的，那么我们就可以回想下static有什么特性了，只能初始化一次，在对象间共享，也就是不同的对象共享同一个static数据，那么当我们Integer b = 127的时候，并没有new出一个新对象来，而是共享了a这个对象的引用，记住，他们共享了同一个引用！！

呵呵，博主我被你这句话小小的误导了一下，其实你这里说的原理没错，但是把位置说错了，这段代码只是初始化cache：

static {

for(int i = 0;i < cache.length;i++)

cache[i] = new Integer(i-128);

}

但真正让cache[i]为static变量的是这句代码：

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];

第五篇：C语言与Java的区别

C语言与Java的区别

一、概览

1、从编程思想来看

C语言 为面向过程语言 Java

为面向对象语言

2、从对地址的可操作性上来看

C语言可以直接对硬件操作 Java 不能直接对硬件操作

小结：在硬件安全性上考虑，Java更安全，不容易引发硬件崩溃

3、从效率上来看

C语言效率非常高，在所有编程语言中名列前茅

Java 执行效率一般，计算效率还不错，总体上来讲效率马马虎虎

4、从可移植性上来看

C语言硬件依赖极高，一旦硬件环境改变，程序运行不能的可能性很高

java 硬件依赖几乎为零，只要机器装有相匹配的虚拟机，任何机器上编写的代码都可以通用

二、语言区别

1、语言背景：

C语言是在单机时代应用非常广泛，它融合了高级语言的简单易用和汇编语言的执行效率。

Java是在研究电子消费产品开发平台和互联网应用的基础上实现的，它的许多语言特性也是从c语言那里沿用和发展，并且使面向对象更加自然和完善（如安全性和代码的移动性）。

2、语言跨平台：

C语言不可以跨平台。

因为Java可以跨平台，在windows 和 unix 等系统上都可以很好的运行。

3、指针管理：

指针是c语言最大的优点，它可以使用户几乎可以访问计算机的所有内存资源和其他部分资源（就是指那里打那里）。同时也是c语言程序最难掌握和调试的问题，并且给系统的安全性和稳定性带来很大的困难。

java中没有指针的概念，尽管也有数组和对象的引用的概念，但它的管理全部交给系统管理，这样限制了用户的资源的访问，但是也给java系统带来安全性和稳定性。JAVA语言让编程者无法找到指针来直接访问内存无指针，并且增添了自动的内存管理功能，从而有效地防止了c语言中指针操作失误，如野指针所造成的系统崩溃。但也不是说JAVA没有指针，虚拟机内部还是使用了指针，只是外人不得使用而已。这有利于Java程序的安全

4、封装

c语言中没有package概念，需要其他方式来实现。

在java中引入了package的概念，使面向对象和面向组件开发更加方便，Java都能够实现面向对象思想（封装，继乘，多态）。JAVA则是完全的面向对象语言，它句法更清晰，规模更小，更易学。它是在对多种程序设计语言进行了深入细致研究的基础上，据弃了其他语言的不足之处，从根本上解决了c语言的固有缺陷。

5、数据类型及类

c语言允许将函数和变量定义为全局的。

Java是完全面向对象的语言，所有函数和变量部必须是类的一部分。除了基本数据类型之外，其余的都作为类对象，包括数组。对象将数据和方法结合起来，把它们封装在类中，这样每个对象都可实现自己的特点和行为。

6、自动内存管理

C语言没有内存管理，必须手动（添加语句）释放内存，增加了程序设计者的负担。Java程序中所有的对象都是用new操作符建立在内存堆栈上，Java自动进行无需内存回收操作，不需要程序员进行删除。Java中当一个对象不被再用到时，无用内存回收器将给它加上标签以示删除。JAVA里无用内存回收程序是以线程方式在后台运行的，利用空闲时间工作。

7、字符串：

C语言不支持字符串变量，在c语言程序中使用Null终止符代表字符串的结束。

Java中字符串是用类对象(strinR和stringBuffer)来实现的，这些类对象是Java语言的核心！

另：

Java没有函数，作为一个比c语言更纯的面向对象的语言，Java强迫开发人员把所有例行程序包括在类中，事实上，用方法实现例行程序可激励开发人员更好地组织编码。