首先，得明白，什么是变量？变量的本质上就是代表一个“可操作的存储空间”，空间的位置是确定的，但是里面放置什么值是不确定。我们可以通过变量名来访问“对应的存储空间”，从而操作这个“存储空间”存储的值。举个生活中的例子可以很好的理解什么是变量，它就相当于我们停车场的车位，我们停车场的车位里面是停什么类型的车辆是不确定的，在于我们使用的车的类型，货车的话车位大一点，轿车是普通的类型，自行车就比较小了。
变量有三大要素：变量名，变量类型，作用域
变量名的命名是有一定的规则的，不能以数字开头，其他部分可以是字母，数字，下划线_,美刀符号$任意组合，因为Java采用Unicode字符集编码，所以变量名是可以使用汉字的，但是不建议使用汉字来作为变量名。
变量的类型：和上面的例子一样，变量可以看作是车位的类型，大车的车位，轿车，自行车。
作用域：在Java中，变量的作用域分为四个级别：类级、对象实例级、方法级、块级。
类级变量又称全局变量或静态变量。需要使用static关键字修饰。类级变量在类定义后就已经存在，占用内存空间，不需要实例化就可以通过类名来访问。从属于类，生命周期伴随类始终，从类加载到卸载。
对象实例级变量就是成员变量，实例化后才会分配内存，才能访问。
方法级变量就是在方法内部定义的变量，就是局部变量。
说明：
方法内部除了能访问方法级的变量，还可以访问类级和实际的变量。
块内部能够访问类级、实例级变量，如果块被包含在方法内部，它还可以访问方法级的变量。

Java入门基础
1、 第一个程序
2、变量(命名、运算、整数/小数/字符串、布尔类型)
3、操作符与表达式(算术/逻辑/关系/赋值/自增/类型转换操作符)
HelloWorld!
public classHelloWorld
{public static voidmain(String[] args)
{//TODO Auto-generated method stub
System.out.println("Hello,World");}
1、变量
定义：“可以变化的量”。
命名规则：数字、字母和下划线组成；不能以数字开头；大写字母与小写字母代表不同的变量名称。
变量组成要素：类型，名称，值
2、变量的表示方法：
类型有 整数(int)、小数(double)、字符串(String),注意此处的S是大写；布尔值(boolean)等~
//整数(int)、小数(double)、字符串(String)
int a = 256;int b = -256;//可以表示为负数//使用double表示小数
double c = 123.456;double d = -349; //相当于-349.0//String表示字符串
String name = "旺哈哈";
String name1= "康师傅";
3、变量的基本运算
- 加法：使用 +
-减法：使用 -
-乘法：使用 *
-除法：使用 /
-取模：使用%，求余
e.g.1
int b1 = 123;int b2 = b1 + 10;int b3 = (b1+b2)*999;
System.out.println("b3等于：" + b3);
e.g.2
System.out.println("乘积：" + (123*456));
System.out.println("数值：" + 12);
System.out.println("12的平方：" + (12*12));
System.out.println("12的立方:" + (12*12*12));//求22的平方及立方
System.out.println("22的平方：" + (22*22));
System.out.println("22的平方：" + (22*22*22));
4、变量的赋值
定义：变量是可变的量，那么就是可以改变的，例如： int a = 0 ; int a = 10 ;使用 “ = ”,等号称为赋值操作符。先将a赋值为0，再赋值为10，最终a 的值是10.
5、布尔类型
boolean在Java语言中被称为布尔类型，表示“是”或“否”,注意：布尔的值只有这两种，其他写法都是错误的。true和false是值，不是字符串，用双引号括起来的才是字符串。
boolean a = true;
boolean b = false;
操作符与表达式
定义：操作符(Operator) ，也称为运算符，比如 + - * / 这些符号都是操作符；表达式(Expression) ，是一个由数值和操作符组成的式子。
1、int 型的算术运算
int型进行运算符运算后，结果还是int型。
需要解释下，除法与模运算
1)除法：取小数点之前的部分：
14/5  结果为 2
2)模运算，取余数 ：
14%5 结果为4
2、浮点型的算术运算
浮点型的算术运算规则也是一样，还是重点看下除法与模运算。
1)浮点型的除法运算，结果保留小数部分
14.0/5.0 结果是2.8
2)浮点型的取模运算，结果为余数
14.0/5.0 结果是4.0
3、类型提升
当整型int 与浮点型double进行运算时，将int型视为double型，这样称为类型的提升。因为double型是可以兼容整型来表示的，为了防止数据丢失。
例：14/5.0 = 2.8
int a = 5;double b = 14.0;
System.out.println("结果为：" + (b/a));
System.out.println("结果为：" + (b%a));
4、混合运算与优先级
原则：先乘除 后 加减
例：5*9 +9/8 -9*8  ---> (5*9) + (9/8) - (9*8)
5、关系操作符
6、逻辑操作符
逻辑与：只有两个都成立才成立(为true)，只要有一个不成立就是false。
逻辑或：两个中只要有一个成立就为true；false || true 结果为true。
逻辑非：表示“否”的意思。！true = false，！false = true
7、区分初始值与赋值
int a = 2 //初始值
int b = 9 //初始值
a = 100+b //重新赋值
8、组合赋值操作符
组合赋值操作：
a+=b;相当于 a = a +b
a-=b;
a/=b;
a*=b;
a%=b;
9、自增/自减操作符(前置自增与后置自增)
//自增操作符 ++ 表示；a++ 理解为a = a+1//自减操作符 -- 表示；b--理解为b = b - 1//前置自增与后置自增
/*后置自增
* int b = 10;
* a = b++
*
* 注意理解，这里最终a =10;b = 11
*
* 后置自增
* int b = 10;
* a = ++b;
*
* 以上内容不是重点，无需多套太多时间
*
* 为了增加代码可读性，可以分开写
* a = b;
* b ++*/
10、操作符的优先级
关系操作符必逻辑操作符优先级高，逻辑非比逻辑与的优先级高。
例子：a > 10 && !ok，优先级换算为：((a>10) &&(！10))
11、类型转换操作符
整型与浮点型之间，容许类型转换，例如：
double a = 12.77;int b = (int) a ; //将double类型转换为int型
其中，a 是double型，b是int 型 ，b = a 时，要求两边的类型一样，所以进行转型操作，double型可以转换为int型，反之也是可以转换。
注意double型向int 型时，会产生数据丢失。int型向double型转换不会产生数据丢失。
例：
double a = 12.2
int b = (int) a //此时b转型为12，小数部分被截掉
int a = 12
double b = double(b) //此时a 为12，没有数据丢失
显示转换与隐式转换
int c = 10;double d = c ;//省略了(double)转换符
语句
int[] a = {11,11,11,11};
a= null;
a[0] = 11;
失去引用对象
//失去引用对象
int[] a = {2,2,2}; //创建一个数组对象，内容是{8,8,8}
a = new int[4]; //创建另一组数组对象，内容是{0,0,0,0}//创建完成后，第一个对象就没有任何引用它，这成为“失去引用”对象
a[0] = a[1] =a[2] = a[3] = 17;
当一个对象失去引用后，就不会再被使用，会由系统自动地回收和销毁这个对象，此过程称为垃圾回收。
数组对象

我想实现这样一个功能：两个Java子类A和B，继承自同一父类，但是它们的成员变量的值各不相同。现在想把A和B合并成C，要求：
1 当A的某成员变量不是null、B的某成员变量是null时，取A的成员变量；
2 当B的某成员变量不是null、A的某成员变量是null时，取B的成员变量；
3 当A和B的某成员变量都不是null时，姑且取B的成员变量。
比如：
class A implements Serializable {
private int roleID = 123456;
private String userName = "一个码农";
private String passWord = "111";
}
class B implements Serializable {
private int roleID = 999;
private String userName;
private String passWord;
}
那么合并之后应该得到：
class C {
private int roleID = 999;
private String userName = "一个码农";
private String passWord = "111";
}
我写了一个比较简单的反射，虽然可以遍历所有成员变量，但是不知道该怎么合并？
public static void combine(Object object1, Object object2) {
Class cls1 = object1.getClass();
Class cls2 = object2.getClass();
Field[] fields1 = cls1.getDeclaredFields();
Field[] fields2 = cls2.getDeclaredFields();
for (int i = 0; i < fields1.length; i++) {
Field f1 = fields1[i];
Field f2 = fields2[i];
f1.setAccessible(true);
f2.setAccessible(true);
try {
// 假设f2就是合并后的C……
if (f2.get(object) == null)
f2.setName(f1.get(object)) ???
else if (f1.get(object) == null)
f2.setName(f2.get(object)) ???
**???**
谢谢了先！

展开全部
java中访问控制符的作用是说明被声明的内容(类、属性、方法和构造方法)的访问权限32313133353236313431303231363533e59b9ee7ad9431333339653662，就像发布的文件一样，在文件中标注机密，就是说明该文件可以被那些人阅读。
访问控制在面向对象技术中处于很重要的地位，合理的使用访问控制符，可以通过降低类和类之间的耦合性(关联性)来降低整个项目的复杂度，也便于整个项目的开发和维护。具体的实现就是通过访问控制符将类中会被其它类调用的内容开放出来，而把不希望别人调用的内容隐藏起来，这样一个类开放的信息变得比较有限，从而降低了整个项目开放的信息，另外因为不被别人调用的功能被隐藏起来，在修改类内部隐藏的内容时，只要最终的功能没有改变，即使改变功能的实现方式，项目中其它的类不需要更改，这样可以提高了代码的可维护性，便于项目代码的修改。
在Java语言中访问控制权限有4种，使用三个关键字进行表达，依次如下：
l  public——公共的
l  protected——受保护的
l  无访问控制符——默认的
l  private——私有的
在实际使用时，类声明的访问控制符只有2个：public和无访问控制符，属性声明、构造方法声明和方法声明的访问控制符可以是以上4种中的任何一个。
这4个访问控制符的权限作用如下表所示：
在4种访问控制中，public一般称作公共权限，其限制最小，也可以说没有限制，使用public修饰的内容可以在其它所有位置访问，只要能访问到对应的类，就可以访问到类内部public修饰的内容，一般在项目中开放的方法和构造方法使用public修饰，开放给项目使用的类也使用public修饰。protected一般称作继承权限，使用protected修饰的内容可以被同一个包中的类访问也可以在不同包内部的子类中访问，一般用于修饰只开放给子类的属性、方法和构造方法。无访问控制符一般称作包权限，无访问控制符修饰的内容可以被同一个包中的类访问，一般用于修饰项目中一个包内部的功能类，这些类的功能只是辅助其它的类实现，而为包外部的类提供功能。private一般称作私有权限，其限制最大，类似于文件中的绝密，使用private修饰的内容只能在当前类中访问，而不能被类外部的任何内容访问，一般修饰不开放给外部使用的内容，修改private的内容一般对外部的实现没有影响。