本文主要是介绍Java培训笔记十二（中信的Java基础归纳），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
JAVA基础知识总结
一．基本数据类型
byte 8位（一字节） char 16位（两个字节）
short 16位（两字节） int 32位（4个字节）
float 32位（四字节） double 64位（8字节）
long 64位（八字节） boolean 8位（一字节）
一共八种，作用：对基本内存空间进行划分
在基本数据类型用注意以下两点：
1在Java中默认的浮点数是double类型的，所以在进行浮点数变量赋值的时候，一定要注意。例如：
float a; //定义了一个单精度浮点类型变量a。
a=1.0；//将一个浮点数1.0赋值给a。
这在java 中是不可以的。你需要这样写：
float a;
a=1.0f；//令1.0为单精度再赋值给a。
2. Java中的布尔值只能是true或者false。不像c语言那样可以用0表示false用其它的数表示true。
二．数据类型的转换
数据类型间的转换有两钟：一种是自动类型转换；条件是：1).两种类型必须兼容； 2).目标类型的取值要大于源类型的取值。二种是强制类型转换。但容易造成精度的丢失。
java中的类型自动提升规则：
one：所有byte类型，short类型，和char类型都将自动提升为int类型
two：如果有一个操作符是long型。则计算结果就是long型
three：如果有一个操作符是float型。则计算结果就是float型
four： 如果有一个操作符是double型。则计算结果就是doubl
3.java中String和int,double数据类型之间的转换：
把String转为int：
String s1="abc";
int i1=Integer.parseInt(s1);
把String转为double：
String s1="abc";
double d1=Double.parseDouble(s1);
把String先转为double，后转为int：
String s1="abc";
int i2=(int)Double.parseDouble(s1);
class zh
{public static void main (String args [])
{String s1="abc";
int i1=Integer.parseInt(s1);
System.out.println(i1);
}
}//为什么编译的时候不报错了，而运行的时候会报错？
将int类型转换不double类型是看自动进行的，而double转换不int需要强制类型转换.
例：
double x=0.999;
int n=(int)x; //强制类型转换是通过截断小数部分转换不整型的
基本类型与其包装器类之间的转换
包装器类 对象变量名＝new 包装器类(基本类型变量);
基本类型 基本类型变量名＝对象变量名. 基本类型Value();
例：
int i=1;
Integer io=new Integer(i);
int b=io.intValue();
数据转换为String类型
String str1=””+基本类型变量;
十进制到其他进制的转换
Integer.toBinaryString(int i); //十进制 转换成二进制
Integer.toHexString(int i); //十进制 转换成十六进制
Integer.toOctalString(int i); //十进制 转换成八进制
toString(int/long i, int radix)方法，可以将一个十进制数转换成任意进制的字符。
byte, short, float和double等数据类型，可以利用Integer或者Long的toBinaryString, toHexString, to OctalString和toString方法转换成其他进制的字符串。
其它进制到十进制的转换
Integer.valueOf("1000", 几进制);
Integer和Long类的valueOf(String source, int r)方法，可以将任意进制的字符串转换成十进制数据。
字节数组与数据类型的转换
整型转换为字节数组，其它类型参考此例
例1：
public static byte[] InttoByteArray(int n)
{
int tmp = n;
byte[] b=new byte[4];
b[3]=new Integer(tmp).byteValue();
tmp=tmp>>8;
b[2]=new Integer(tmp).byteValue();
tmp=tmp>>16;
b[1]=new Integer(tmp).byteValue();
tmp=tmp>>24;
b[0]=new Integer(tmp).byteValue();
return b;
}
例2：
public static byte[] InttoByteArray(int n)
{
int tmp1 = n;
byte[] b=new byte[4]; //整型需要4个字节存储
for (int i = b.length - 1; i >=0; i--)
{
//int的后8位转换为byte型
b[i] = new Integer(tmp1).byteValue();
tmp1 = tmp1 >> 8;
}
return b;
}
字节数组转换为整型
byte[] b=new byte[4];
b[0]=0;
b[1]=0;
b[2]=39;
b[3]=16;
public static int toInteger(byte[] b)
{
int s=0;
s=b[0] * 256 * 256 * 256 + b[1] * 256 * 256 +b[2] * 256+b[3];
return s;
}
boolean类型转换为String
例一：Boolean b=true;
String str1=b.valueOf(b);
例二：
Boolean b=new Boolean(true);
String str2=b.toString();
三．变量
对于第一种变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。
int类型变量默认初始值为0
float类型变量默认初始值为0.0f
double类型变量默认初始值为0.0
boolean类型变量默认初始值为false
char类型变量默认初始值为0(ASCII码)
long类型变量默认初始值为0
所有对象引用类型变量默认初始值为null，即不指向任何对象。注意数组本身也是对象，所以没有初始化的数组引用在自动初始化后其值也是null。
对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。这个问题会在以后的系列中进行详细讨论。
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。
声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：
1.它们仅能调用其他的static 方法。
2.它们只能访问static数据。
它们不能以任何方式引用this 或super（关键字super 与继承有关）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Static block initialized.");
b = a * 4;
}
public static void main(String args[]) {
meth(42);
}
}
一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。
注意：在一个static 方法中引用任何实例变量都是非法的。
下面是该程序的输出：
Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：
classname.method( )
这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。
下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
下面是该程序的输出：
a = 42
b = 99
四．java中类,对象和引用间的关系
类：是对现实存在事物的一种抽象，一种高度的概括。
对象：是类的实例，是类中的一个个体，它具有该类的属性。
引用：当你引入一个包时，你可以引用该包内的类的对象，也就是说，引用针对的是类的对象。
定义一个类
class ccircle
{ int r=20;
float d=2*r;
}
public class zh
{ public static void main (String args[])
{
ccircle cir1=new ccircle();
ccircle cir2=new ccircle();//在这个时候已经在堆中开辟了两个内存空间用
System.out.println(cir1.r);
/*
*引用类的对象，基本数据类型变量名输出的是值,内存分配在栈。
而引用类型输出的是地址，内存分配在堆。
*
*/
System.out.println(cir1);
System.out.println(cir2);
}
四．算术运算符 + - * % (取模) /(取商)
比较运算符 基本数据类型 值 引用（引用的是比较地址） ！= ==
比较两个对象的值如 p.equals(p1)
逻辑运算符 && || ~ ?:
任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下一行一行地执行，中间没有任何判断和跳转。
如果main方法多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。这意味着：如果没有流程控制，Java方法里的语句是一个顺序执行流，从上向下依次执行每条语句。
Java提供了两种常见的分支控制结构：if语句和switch语句，其中if语句使用布尔表达式或布尔值作为分支条件来进行分支控制；而switch语句则用于对多个整型值进行匹配，从而实现分支控制。
if语句使用布尔表达式或布尔值作为分支条件来进行分支控制，其中if语句有如下三种形式：
第一种形式：
if ( logic expression )
{
statements...
}
第二种形式：
if (logic expression)
{
statements...
}
else
{
statements...
}
第三种形式：
if (logic expression)
{
statements...
}
else if(logic expression)
{
statements...
}
...//可以有零个或多个else if语句
else//最后的else语句也可以省略
{
statement..
}
在上面if语言的三种形式中，放在if之后的括号里的只能是一个逻辑表达式，即这个表达式的返回值只能是true或false。第二种情形和第三种情形是相通的，如果第三种形式中else if块不出现，则变成了第二种形式。
上面的条件语句中，if(logic expression)、else if(logic expression)以及else后花括号括起来多行代码被称为代码块，一个代码块通常被当成一个整体来执行（除非运行过程中遇到return、break、continue等关键字，或者遇到了异常），因此这个代码块也被称为条件执行体。例如如下程序：
public class TestIf
{
public static void main(String[] args)
{
int age = 30;
if (age > 20)
//只有当age > 20时，下面花括号括起来的语句块才会执行
//花括号括起来的语句是一个整体，要么一起执行，要么一起不会执行
{
System.out.println("年龄已经大于20岁了");
System.out.println("20岁以上的人应该学会承担责任...");
}
}
}
因此，如果if(logic expression)、else if(logic expression)和else后的语句块只有一行语句时，则可以省略花括号，因为单行语句本身就是一个整体，无须花括号来把它们定义成一个整体。下面代码完全可以正常执行：
//定义变量a ，并为其赋值
int a = 5;
if (a > 4)
//如果a>4，执行下面的执行体，只有一行代码作为代码块
System.out.println("a大于4");
else
//否则，执行下面的执行体，只有一行代码作为代码块
System.out.println("a不大于4");
通常，我们建议不要省略if、else、else if后执行块的花括号，即使条件执行体只有一行代码，因为保留花括号会有更好的可读性，而且保留花括号会减少发生错误的可能，例如如下代码，则不可正常执行：
//定义变量b ，并为其赋值
int b = 5;
if (b > 4)
//如果b>4，执行下面的执行体，只有一行代码作为代码块
System.out.println("b大于4");
else
//否则，执行下面的执行体
b--;
//对于下面代码而言，它已经不再是条件执行体的一部分，因此总会执行
System.out.println("b不大于4");
上面代码中以粗体字标识的代码行：System.out.println("b不大于4");，将总是会执行，因为这行代码并不属于else后的条件执行体，else后的条件执行体就是b--;这行代码。
3 控制循环结构
Java语言没有提供goto语句来控制程序的跳转，这种做法提高了程序流程控制的可读性，但降低了程序流程控制的灵活性。为了弥补这种不足，Java提供了continue和break来控制循环结构。除此之外，return可以结束整个方法，当然也就结束了一次循环。在某些时候，我们需要在某种条件出现时，强行终止结束循环，而不是等到循环条件为false时。此时，可以使用break来完成这个功能。break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统将完全结束该循环，开始执行循环之后的代码。例如如下程序：
public class TestBreak
{
public static void main(String[] args)
{
//一个简单的for循环
for (int i = 0; i < 10 ; i++ )
{
System.out.println("i的值是" + i);
if (i == 2)
{
//执行该语句时将结束循环
break;
}
}
}
}
运行上面程序，将看到i循环到2时即结束，当i等于2时，循环体内遇到break语句，程序跳出该循环。
break语句不仅可以结束其所在的循环，还可直接结束其外层循环。此时需要在break后紧跟一个标签，这个标签用于标识一个外层循环。
Java中的标签就是一个紧跟着英文冒号（:）的标识符。与其他语言不同的是，Java中的标签只有放在循环语句之前才有作用，例如下面代码：
public class TestBreak2
{
public static void main(String[] args)
{
//外层循环，outer作为标识符
outer:
for (int i = 0 ; i < 5 ; i++ )
{
//内层循环
for (int j = 0; j < 3 ; j++ )
{
System.out.println("i的值为:" + i + " j的值为:" + j);
if (j == 1)
{
//跳出outer标签所标识的循环。
break outer;
}
}
}
}
}
运行上面程序，看到如下运行结果：
i的值为:0 j的值为:0
i的值为:0 j的值为:1
当程序从外层循环进入内层循环后，当j等于1时，程序遇到一个break outer;语句，这行代码将会导致结束outer标签指定的循环，不是结束break所在的循环，而是结束break循环的外层循环。所以看到上面的运行结果.
4.while结构和do { } while;结构
Int k=0;
while (k<100)
{Syetem.out.println(“hello”);
k++；
}
在本例中k是计数器。它从0开始计数到99.即它计数了100次，特点：先判断后执行
Int k=0;
do
{Syetem.out.println(“hello”);
k++；
} while (k<100)
在本例中k是计数器。它从0开始计数到100.即它计数了101次,特点:先执行后判断。
这篇关于Java培训笔记十二（中信的Java基础归纳）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
