1.const和goto是保留关键字。true和false看起来像关键字，但严格来说，它们是boolean常量；null看起来也像关键字，但严格来说，它是null常量。
综上，true,false,null不是关键字。而是常量。
2.数组如果初始化赋值为空，则以后再赋值不为空则会出错。
3.java声明变量不赋值，会警告，但是如果以后调用则编译会出错，导致便宜不能通过。
4.boolean类型不能和任何类型进行转换。
5.double d=0x12345678
6.long test=012（长整形）
7.byte的取值范围是-128—127
8.重载只要求参数列表不同，回值无关
9.int []d[]定义一个二维数组
10.在进程中，重要性依次是：前台进程、可见进程、服务进程、后台进程、空进程。所以销毁的顺序为逆方向。
11.android 默认使用 sp作为字号单位
12.aidl对应的接口名称必须与aidl文件名相同不然无法自动编译
| 操作方式 | 数据位置 | 明文密文 | 数据安全 | 长度限制 | 应用场景 |
| GET | HTTP包头 | 明文 | 不安全 | 长度较小 | 查询数据 |
| POST | HTTP正文 | 可明可密 | 安全 | 支持较大数据传输 | 修改数据 |
3、group by子句将数据划分为多个分组；
4、使用聚集函数进行计算；
5、使用having子句筛选分组；
6、select计算所有的表达式；
7、使用order by对结果集进行排序。
|
1
2
3
4
5
|
typedef
struct
list_t{
struct
list_t *next;
struct
list_t *prev;
char
data[0];
}list_t;
|
方便管理内存缓冲区
减少内存碎片化
|
1
2
3
4
5
|
struct
{
char
a[10];
int
b;
short
c[3];
}
偏移量必须为其类型的整数倍，结构体大小必须是所有成员大小的整数倍
char 偏移量0，地址0-9
int 偏移量10不是sizeof(int)的倍数，故而修正为12，地址12-15
short 偏移量16，地址16-21
结构题大小22不是1，2，4的公倍数，故而vc自动补充2个数为24
|
0x78,0x56,0x34,0x12
27.
开发C代码时,经常见到如下类型的结构体定义:
1
2
3
4
5
typedef
struct
list_t{
struct
list_t *next;
struct
list_t *prev;
char
data[0];
}list_t;
请问在32位系统中,sizeof(list_t)的值为
把单一元素的数组放在一个struct的尾端，使得每个struct对象可以拥有可变大小的数组。
开始题目中的
char data[0] 或写成
char data[]，即为柔性数组；
data
不占用struct的空间，只是作为一个符号地址存在。 因此sizeof的值是两个指针所占字节，即4+4 = 8字节。
28.四层模型对应的协议
应用层http，ftp
传输层tcp，udp
网络层ip
物理层arp
29.
1.线程休眠sleep();:线程有优先级，但是我们可以用此方法人为的改变它们的优先级，让线程暂停，它其他线程获得分配空间。
用法：Thread.sleep（2000）;//休眠两秒
2.线程让步yield();就是让出自己的分配空间给其他线程，那么问题来了，让步多久呢？如果有两条线程的话，是不是让步到另外一条线程执行完呢？经测试，不是让另外的线程执行，让步时间是不确定的；
注意：当某个线程调用yield()方法之后，只有与当前线程优先级形同或者更高的才能获得执行机会。
用法：一般都是指定条件，如if（i==10）{Thread.yield();}
3.线程插队join（）：当某个程序调用其他线程的join（）时，调用线程将会阻塞，直到插入的线程运行完毕，才运行该线程，如main线程中for(int i = 0; i < 100; i++){if(i == 2){t.join();}}，当i等于2时，线程t将执行完毕再执行main中余下的 i= 3 i=4 ……
用法：一般都是指定条件，如if（i==10）{t.join();} 注意插队肯定是在别的线程中插别人的队，不可能在自己的线程中写join(); 如 ：t线程中写t.join();，这种方法是不正确的。
4.wait()：当前线程放弃同步锁进入等待状态，直到其他线程进入此同步锁notify（）或notifyAll（）唤醒线程为止。
5.notify（）：唤醒锁上等待的第一个调用wait（）方法的线程。
6.notifyAll（）：唤醒同步锁上调用wait（）的所有线程。
注意：wait()、notify（）、notifyAll（）必须是同步锁对象。
wait()、notify（）、notifyAll（）方法用法：
java重写与重载的区别
首先我们来讲讲：重载(Overloading)
（1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是一个类中多态性的一种表现。
（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
下面是重载的例子：
package c04.answer;//这是包名
//这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用this关键字调用不同的bark方法。
不同的重载方法bark是根据其参数类型的不同而区分的。
//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。
package c04.answer;
public class Dog {
Dog()
{
this.bark();
}
void bark()//bark()方法是重载方法
{
System.out.println(\"no barking!\");
this.bark(\"female\", 3.4);
}
void bark(String m,double l)//注意：重载的方法的返回值都是一样的，
{
System.out.println(\"a barking dog!\");
this.bark(5, \"China\");
}
void bark(int a,String n)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分
{
System.out.println(\"a howling dog\");
}
public static void main(String[] args)
{
Dog dog = new Dog();
//dog.bark(); [Page]
//dog.bark(\"male\", \"yellow\");
//dog.bark(5, \"China\");
然后我们再来谈谈 重写（Overriding）
（1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
（3）子类函数的访问修饰权限不能少于父类的；
下面是重写的例子：
概念：即调用对象方法的机制。
动态绑定的内幕：
1、编译器检查对象声明的类型和方法名，从而获取所有候选方法。试着把上例Base类的test注释掉，这时再编译就无法通过。
2、重载决策：编译器检查方法调用的参数类型，从上述候选方法选出唯一的那一个（其间会有隐含类型转化）。
如果编译器找到多于一个或者没找到，此时编译器就会报错。试着把上例Base类的test(byte b)注释掉，这时运行结果是1 1。
3、若方法类型为priavte static final ，java采用静态编译，编译器会准确知道该调用哪
个方法。
4、当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用对象的实际类型相匹配的方法版本。
在例子中，b所指向的实际类型是TestOverriding，所以b.test(0)调用子类的test。
但是，子类并没有重写test(byte b)，所以b.test((byte)0)调用的是父类的test(byte b)。
如果把父类的(byte b)注释掉，则通过第二步隐含类型转化为int,最终调用的是子类的test(int i)。
学习总结：
多态性是面向对象编程的一种特性，和方法无关，
简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，即方法的
重载——有不同的参数列表（静态多态性）
而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，
即在子类中重写该方法——相同参数，不同实现（动态多态性）
OOP三大特性：继承，多态，封装。
public class Base
{
void test(int i)
{
System.out.print(i);
}
void test(byte b)
{
System.out.print(b);
}
}
public class TestOverriding extends Base
{
void test(int i)
{
i++;
System.out.println(i);
}
public static void main(String[]agrs)
{
Base b=new TestOverriding();
b.test(0)
b.test((byte)0)
}
}
这时的输出结果是1 0，这是运行时动态绑定的结果。
重写的主要优点是能够定义某个子类特有的特征：
public class Father{
public void speak(){
System.out.println(Father);
}
}
public class Son extends Father{
public void speak(){
System.out.println("son");
}
}
这也叫做多态性，重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。
当上例中Father类speak()方法被private时，Son类不能重写出Father类speak()方法，此时Son类speak()方法相当与在Son类中定义的一个speak()方法。
Father类speak()方法一但被final时，无论该方法被public,protected及默认所修饰时，Son类根本不能重写Father类speak()方法，
试图编译代码时，编译器会报错。例：
public class Father{
final public void speak(){
System.out.println("Father");
}
}
public class Son extends Father{
public void speak(){
System.out.println("son");
}
} //编译器会报错；
Father类speak()方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。
Father类speak()方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。
重写方法的规则：
1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）
4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：
父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。
而重载的规则：
1、必须具有不同的参数列表；
2、可以有不责骂的返回类型，只要参数列表不同就可以了；
3、可以有不同的访问修饰符；
4、可以抛出不同的异常；
重写与重载的区别在于：
重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。
用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.
1.flavor
n.
味;香料;韵味;特点
vt.
给…调味;给…增添风趣
2.meta
元
abbr.
（希腊语）在…之后或超出;[辨证法]元语言
3.”static”关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？
参考答案
“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。
Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。
java中也不可以覆盖private的方法，因为private修饰的变量和方法只能在当前类中使用，如果是其他的类继承当前类是不能访问到private变量或方法的，当然也不能覆盖。
4.是否可以在static环境中访问非static变量？
参考答案
static变量在Java中是属于类的，它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。
5.Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？
参考答案
Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。
6.Java中，什么是构造方法？什么是构造方法重载？
参考答案
当新对象被创建的时候，构造方法会被调用。每一个类都有构造方法。在程序员没有给类提供构造方法的情况下，Java编译器会为这个类创建一个默认的构造方法。
Java中构造方法重载和方法重载很相似。可以为一个类创建多个构造方法。每一个构造方法必须有它自己唯一的参数列表。
7.接口和抽象类的区别是什么？
参考答案
Java提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：
接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
抽象类可以在不提供接口方法实现的情况下实现接口。
Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。
也可以参考JDK8中抽象类和接口的区别
8.接口和抽象类的区别是什么？
参考答案
Java提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：
接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
抽象类可以在不提供接口方法实现的情况下实现接口。
Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。
也可以参考JDK8中抽象类和接口的区别
9.什么是值传递和引用传递？
参考答案
值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量.
引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。
一般认为,java内的传递都是值传递. java中实例对象的传递是引用传递
10.进程和线程的区别是什么？
参考答案
进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。线程又叫做轻量级进程。
线程的划分小于进程，线程隶属于某个进程。 进程是程序的一种动态形式，是CPU、内存等资源占用的基本单位，而线程是不能占有这些资源的。 进程之间相互独立，通信比较困难，而线程之间共享一块内存区域，通信比较方便。 进程在执行的过程中，包含比较固定的入口，执行顺序，出口，而线程的这些过程会被应用程序所控制
11.在Java中，对象什么时候可以被垃圾回收？
参考答案
当对象对当前使用这个对象的应用程序变得不可触及的时候，这个对象就可以被回收了。
12.封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。在Java当中，有3种修饰符：public，private和protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。
下面列出了使用封装的一些好处：
通过隐藏对象的属性来保护对象内部的状态。
提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展。
禁止对象之间的不良交互提高模块化。
参考这个文档获取更多关于封装的细节和示例。
或：
一是用private把类的细节与外界隔离起来，从而实现数据项和方法的隐藏，而要访问这些数据项和方法唯一的途径就是通过类本身，类才有资格调用它所拥有的资源（方法，数据项属性等等）。所以第一个好处就是数据的安全性提高了。
二是通过隐藏隔离，只允许外部对类做有限的访问，开发者可以自由的改变类的内部实现，而无需修改使用该类的那些程序。只要那些在类外部就能被调用的方法保持其外部特征不变，内部代码就可以自由改变，各取所需，利于分工。
三就是提高了代码的重用性，封装成工具类以后能够减少很多繁琐的步骤。
扫一扫
712
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
