JAVA基础知识

kuixun

已于 2024-06-23 11:04:37 修改

阅读量485

点赞数

分类专栏： java 文章标签： java

于 2015-05-30 11:02:56 首次发布

本文链接：https://blog.csdn.net/u012123938/article/details/46272631

版权

java 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

变量

Java共有8种基本类型：4种整型，2种浮点数型，1种字符型，以及用于表示真假的布尔类型。除了基本数据类型之外，都属于引用数据类型。

算术运算符 +,-,*,/,%,++,-- ：
% 取余数
   如果左边大于右边，结果是余数
   如果左边小于右边，结果是左边
   如果左边等于右边，结果是0
   正负号跟左边一致
++与--：
++其实相当于把数据+1
--其实相当于把数据-1

关系运算符：==,!=,>,>=,<,<=，结果都是 boolean 类型。

逻辑运算符：&与 |或 ^异或 !非 &&短路与 ||短路或运
& 两边有一个是 false，结果为 false

true  &  true   =  true;
true  &  false  =  false;
false &  true   =  false;
false &  false  =  false;

| 两边都为 false，结果为 false

true  |  true   =  true;
true  |  false  =  true;
false |  true   =  true;
false |  false  =  false;

^ 两边结果相同，结果为 false

true  ^ true  = false;
true  ^ false = true;
false ^ true = true;
false ^ false = false;

! 判断事物的反面

!true=false;
!false=true;
!!true=true;

&& 和 & 的结果是一样的
区别：
& 无论左边的运算结果是什么，右边都参与运算
&& 当左边为 false 时，右边不参与运

|| 和 | 的结果是一样的
区别：
| 无论左边的运算结果是什么，右边都参与运算
|| 当左边为 true 时，右边不参与运算

三元运算符

int x = 3, y =4;
z = (x > y) ? x:  y;

循环

一.判断结构
if：语句用于做判断使用的。
常见于对某个范围进行判断，或者几个变量进行判断，还有就是boolean表达式的判断。

判断语句三种格式：

if(条件表达式){
    执行语句;
}

执行流程：如果条件表达式为true，就执行语句，否则，什么都不执行。

if(条件表达式){
    if语句执行体;
}else{
    else语句执行体;
}

执行流程：如果条件表达式为true，就if语句执行体；否则，就执行else语句执行体；

if(条件表达式){
    if 语句执行体;
}else if(条件表达式){
    else if 语句执行体;
}else{
    else 语句执行体;
}

注意事项
1.if语句执行完会执行另外一个语句吗？
每一种if语句其实都是一个整体，如果有地方执行了，其他的就不执行了。
2.大括号需要每次都写上吗？
如果if或者else里面控制的语句体是一条语句，是可以省略大括号的，如果if里面有多条语句，就必须写上大括号。
4:大括号和分号一般不同时出现。

    if(true)
        System.out.println("true");
    else
        System.out.println("false");;

举例：获取两个数中的最大值。
//因为获取俩个数中的最大值必须有一个结果.所以可以先考虑三元运算符。

int x=1,y=2,z;
z=(x>y)?x:y;

二.选择结构
switch 语句
用于做选择使用，一般用于几个常量的判断。
switch 语句会把几个常量值直接加载到内存，在判断的时候，效率要比 if 语句高。
所以，针对几个常量的判断，一般选择 switch 语句。
格式：

switch(变量){
    case 变量 1：
        执行语句;
    break;
    case 变量 2：
        执行语句;
    break;
    ...
    default://都不匹配的默认执行
        执行语句;
    break;//结束
}

执行流程：进入 switch 语句后，就会根据变量的值去找对应的 case 值，如果最终没有找到，那么，就执行 default 的内容。
注意事项：
1.default 整体可以省略吗?
   可以，但是不建议。
2.default 的位置可以放到前面吗?
   可以，但是不建议。
3.break可以省略吗?
   可以，但是不建议。default 在最后，default 的 break 是可以省略的，但是结果可能有问题。
4.switch 语句什么时候结束呢?
   就是遇到 break 或者执行到程序的末尾。
   if 和 switch 的应用：
if 特点:
   1.对具体的值进行判断。
   2.对区间判断。
   3.对运算结果是 boolean 类型的表达式进行判断。
switch 特点:
   1.对具体的值进行判断。
   2.值的个数通常是固定的，对于几个固定的值判断，建议使用 switch 语句 switch 会将具体的答案都加载进内存，效率高一点。
   3.switch只能对基本数据类型进行操作 byte,short,int,char
三.循环结构
循环语句：while, do while, for

while 格式：
while(条件表达式) {
    循环执行体; //先判断后执行；
}

do while 格式：
do {
    循环执行体; //先执行一次后判断。
} while(条件表达式);

for 格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式) {
    执行语句;(循环体)
}

注意事项：
1.什么时候用循环语句？
   当对某些语句执行很多次时，就使用循环结构。
2.什么情况用 for，什么情况用 while？
   for 和 while 可以互换。如果用于定义循环增量，用 for 更合适，因为节约内存。
   为了书写的简洁，也是可以用 while，因为容易看。

嵌套循环:

for(初始化表达式; 条件表达式; 循环后的操作表达式) {
    for(初始化表达式; 条件表达式; 循环后的操作表达式) {
        // 执行体
    }
}
while(条件表达式) {
    while(条件表达式) {
        // 执行体
    }
}

注意：
1.while 和 for 可以互换，区别在于 for 为了循环而定义的变量在 for 循环结束就是在内存中释放。而 while 循环使用的变量在循环结束后还可以继续使用。
2.最简单无限循环格式：while(true)，for(;;)无限循环存在的原因是并不知道循环多少次。

break 和 continue
break：跳出，应用于选择结构和循环结构。
continue：继续，应用于循环结构。
注意：
1.这两个语句离开应用范围，单独存在没有意义。
2.这两个语句单独存在下面都不只可以有语句，因为执行不到。
3.continue 是结束本次循环继续下次循环，结束之后会去判断表达式。

数组

1.数组的概述：
(1).概念：同一种类型数据的集合。其实数组就是一个容器。
(2).好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
(3).对数组的基本操作就是存和取。核心思想：基于角标。
(4)既可以存储基本数据类型又可以存储引用类型，只是长度固定。集合长度可变，但只能存储引用类型。

2.数组的定义：
1）元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
2）元素类型[] 数组名 = {1,2,3,4,5,6,7};
3）元素类型[] 数组名；

数组名 = new 元素类型[元素个数或数组长度];

3.数组的特点：
1）数组定义时，必须明确数组的长度(就是数组中可以存储的元素的个数。)因为数组长度是固定的。
2）数组定义时，必须明确数组中的元素的数据类型。
例子：

char[] arr = new char[5];
arr[0] ='黑';
arr[1] ='牛';

4.数组的内存结构：
Java内存区域的划分：寄存器本地方法区方法区栈内存堆内存
为什么划分这么区域？因为每一个内存区域对数据的处理方式不同。目前要讲的就是栈和堆。
1）栈内存的特点：存储的都是局部变量，如：函数参数，函数内定义的变量，语句中定义的变量，变量一旦使用完(作用域结束)，就会在栈内存中自动释放。
2）堆内存特点：存储的是实体
   1.堆内存中的实体都有首内存地址值.
   2.堆内存中的变量都有默认初始化值.
   3.对于没有任何引用变量指向的实体，会视为垃圾，会被垃圾回收机制所回收。(数组和对象，只要是new的，都在堆内存中)

5.操作数组时常见问题：
A.数组角标越界异常(ArrayIndexOutOfBoundsException):操作数组时，访问到了数组中不存在的角标。
B.空指针异常(NullPointerException)：当引用没有任何指向值为null的情况，该引用还在用于操作实体。

6.对数组的常见操作：1.获取数组中的元素 2.获取最值 3.排序（冒泡排序最大的在最后、选择排序） 4.查找（折半查找只针对有序）插入（针对有序）
1).获取数组中的元素，通常会用到遍历：
2).获取最值：
/**
*最大值思路：
*1.需要进行比较。并定义变量记录住每次比较后较大的值。
*2.对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
* 如果遍历到的元素大于变量中记录的元素，就用变量记录住较大的值。
*3.遍历结果，该变量记录就是最大值。
*定义一个功能来是实现。
*明确一，结果，是数组中的元素。int .
*明确二，未知内容。数组.
*
*最小值思路：
*1.需要进行比较。并定义变量记录住每次比较后较小的值。
*2.对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
* 如果遍历到的元素小于变量中记录的元素，就用变量记录住较小的值。
*3.遍历结果，该变量记录就是最小值。
*定义一个功能来是实现。
*明确一，结果，是数组中的元素。int .
*明确二，未知内容。数组.
*/
3).排序：

    /*排序（选择排序，冒泡排序）*/  
    public static void swap(int[] arr,int x,int y) {
        int temp = arr[x];
        arr[x]= arr[y];
        arr[y]= temp;
    }
    /*冒泡排序*/  
    public static void bubbleSort(int[] arr) {
        for(int x=0; x<arr.length-1; x++) {
            for(int y=0; y<arr.length-1-x; y++) {
                if(arr[y]>arr[y+1]) {
                    swap(arr,y,y+1);
                }
            }
        }
    }
    /*选择排序*/  
    public static void selectSort(int[] arr) {
        for(int x=0; x<arr.length-1; x++) {
            for(int y=x+1; y<arr.length; y++) {
                if (arr[x] > arr[y]) {
                    swap(arr,x,y);
                }
            }
        }
    }

7.数组的工具类 Arrays：用于操作数组用其工具类，此类包含用来操作数组（比如排序和搜索）的各种方法。
其主要方法为：
   1.排序：Arrays.sort( arr );
   2.二分查找：Arrays.binarySearch(arr, key); //如果它包含在数组中，则返回搜索键的索引；否则返回(-(插入点) - 1)。
   3.复制指定的数组：Arrays.copyOf(arr, newLength); //返回新数组，长度不足则填充响应值。
   4.复制指定范围的数组：Arrays.copyOfRange(arr,from,end); //含头不含尾
   5.toString：Arrays.toString(arr); //返回数组的字符串形式

9.利用数组进行进制转换

public static void toBin(int num){
    //定义二进制的表
    char[] chs = {'0','1'};

    //定义一个临时存储容器
    char[] arr = new char[32];

    //定义一个操作数组的指针
    int pos = arr.length; 
    while(num!=0){
        int temp = num & 1;
        arr[--pos] = chs[temp];
        num = num >>> 1;
    }

    for(int x=pos; x<arr.length; x++){
        System.out.print(arr[x]);
    }
}

public static void trans(int num,int base,int offset){
    if(num==0){
        System.out.println(0);
        return;
    }

    char[] chs = {
    '0','1','2','3',
    '4','5','6','7',
    '8','9','A','B',
    'C','D','E','F'};

    //定义一个临时容器
    char[] arr = new char[32];
    int pos = arr.length;

    while(num!=0){
        int temp = num & base;
        arr[--pos] = chs[temp];
        num = num >>> offset;
    }

    System.out.println("pos="+pos);

    //存储数据的arr数组遍历
    for(int x=pos;x<arr.length; x++) {
        System.out.print(arr[x]);
    }
}
//二进制
public static int toBin(int num){
    trans(num,1,1);
}
//八进制
public static int toBa(int num){
    trans(num,7,3);
}
//十六进制
public static int toHex(int num){
    trans(num,15,4);
}

二维数组

1.什么是二维数组：就是一个一维数组。

2.二维数组格式：
(1).方式1:元素类型[][] 数组名 = new 元素类型[3][2];
例子:

int[][] arr = new int[3][2];

解释：
   定义了名称为 arr 的二维数组
   二维数组中有3个一维数组
   每一个一维数组中有2个元素
   一维数组的名称分别为 arr[0], arr[1], arr[2]
   给第一个一维数组1索引位赋值为78写法是：arr[0][1] = 98;

(2).方式2：元素类型[][] 数组名 =new 元素类型[3][];
例子:int[][] arr = new int[3][];
解释：
   二维数组中有3个一维数组元素
   每个一维数组都是默认初始化值null
   可以对这个三个一维数组分别进行初始化

arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];

(3).方式3：元素类型[][] 数组名 = {{一维数组元素}{一维数组元素}{一维数组元素}};

int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

3.二维数组的遍历

思路：
(1).二维数组的每一个元素是一维数组，获取到每一个一维数组。
(2).一维数组的遍历。

class Test{
	public static void main(String[] args) {
		//二维数组的遍历
		int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
		//arr.length 获取二维数组的长度，其实也就是一维数组的个数
		for(int x=0; x<arr.length; x++) {
			//arr[x].length 获取的是每一个一维数组的长度
			for(int y=0; y<arr[x].length; y++){
				//arr[x][y] 获取的是二维数组的元素
				System.out.print(arr[x][y]+"\t");
			}
			System.out.println();
		}
	}
}

abstract

abstract（抽象）修饰符，可以修饰类和方法

1.abstract 修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
2.abstract 修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以";"代替。需要子类继承实现（覆盖）。

注意：
   有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。
   abstract 修饰符在修饰类时必须放在类名前。
   abstract 修饰方法就是要求其子类覆盖（实现）这个方法。调用时可以以多态方式调用子类覆盖（实现）后的方法，也就是说抽象方法必须在其子类中实现，除非子类本身也是抽象类。
   父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。

例子：

abstract class E{
	public abstract void show(); //public abstract 可以省略
}
//然后其它类如果继承它通常为了实现它里面的方法
class F extends E{
    void show(){
		//写具体实现的代码 
	}
}
//最后再主方法里面定义一个父类引用指向子类对象，就会发生多态现象 
E e = new F();
e.show(); //调用子类的 show() 方法

继承

1.构造函数：当子类继承一个父类时，构造子类时需要调用父类的构造函数，存在三种情况

父类无构造函数或者一个无参数构造函数，子类若无构造函数或者有无参数构造函数，子类构造函数中不需要显式调用父类的构造函数，系统会自动在调用子类构造函数前调用父类的构造函数；
父类只有有参数构造函数，子类在构造方法中必须要显示调用父类的构造函数，否则编译出错；
父类既有无参数构造函数，也有有参构造函数，子类可以不在构造方法中调用父类的构造函数，这时使用的是父类的无参数构造函数；

2.方法覆盖：

子类覆盖父类的方法，必须有同样的参数返回类型，否则编译不能通过；
子类覆盖父类的方法，在jdk1.5后，参数返回类可以是父类方法返回类的子类；
子类覆盖父类方法，可以修改方法作用域修饰符，但只能把方法的作用域放大，而不能把public修改为private；
子类方法能够访问父类的protected作用域成员，不能够访问默认的作用域成员；
子类的静态方法不能隐藏同名的父类实例方法；
java与C++一样，继承的方法具有多态性；

3.成员覆盖：

当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量；

这个听起来很容易理解的一回事，但是实际使用过程中很多人容易搞混：尤其是在多态的时候，调用一个被继承的方法，该方法访问是一个被覆盖的成员m，那么方法中到底是访问了父类的成员还是子类的成员m？结论是，若实际调用的是父类的方法，就使用了父类的该成员m,若实际调用的是子类的方法，就使用子类的成员m，记住一句，每个类使用成员都相当于在前面加了一个this指针。

举例：

class SuperClass {
    private int number;

    public SuperClass() {
        this.number = 0;
    }

    public SuperClass(int number) {
        this.number = number;
    }

    public int getNumber() {
        number++;
        return number;
    }
}

class SubClass1 extends SuperClass {
    public SubClass1(int number) {
        super(number);
    }
}

class SubClass2 extends SuperClass {
    private int number;

    public SubClass2(int number) {
        super(number);
    }
}

public class SubClass extends SuperClass {
    private int number;  

    public SubClass(int number) {
        super(number);
    }

    public int getNumber() {
        number++;
        return number;
    }

    public static void main(String[] args) {
        SuperClass s = new SubClass(20);
        SuperClass s1 = new SubClass1(20);
        SuperClass s2 = new SubClass2(20);
        System.out.println(s.getNumber());
        System.out.println(s1.getNumber());
        System.out.println(s2.getNumber());
        //结论一：多态时，当子类覆盖了父类的方法，使用子类覆盖的方法
        //结论二：当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量
    }
}

执行输出：
1
21
21