黑马程序员——java基础（一）

------- android培训、java培训、期待与您交流！ ----------

前言：通过观看毕向东老师的java基础视频，查漏补缺，将一些自己掌握的还不牢固的知识写出来，希望和大家交流分享。

1.java的特性和优势

 Java 的特性和优势：简单性、面向对象、可移植性（write once，run anywhere）、高性能、分布式、劢态性、多线程、安全性、健壮性。

 Java的跨平台：Java有一个自己独立的能解析Java软件的解析器，称之为虚拟机，即JVM（Java Virtual Machine Java虚拟机）。只要在需要运行Java应用程序的操作系统上，先安装一个JVM就可以了，接下来就由JVM来负责Java程序在该系统中的运行。这样就实现了Java程序的跨平台性，也称为Java具有良好的可移植性。

2.数据类型

一张图来说明java的数据类型

说明：1.基本数据类型默认值：整数类型：默认初始化为0

                                       浮点型：默认初始化为0.0

                                       字符型：默认初始化为null

                                       布尔型：默认初始化为false

              2.在内存中的位置：基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈内存上；

                                                 引用数据类型在被创建时，首先要在栈上给其引用分配一块内存，而对象的具体信息存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。
              3.类型的自动提升：在运算中，当低类型数据与高类型数据进行计算时，系统会自动将表达式中的低类型数据提升到高类型。
                     强制类型转换： 当程序中，数据类型需要变换时，可以进行强制转换。

3.流程控制之switch

switch的结构：

  switch(表达式)

 {

       case取值1: 执行语句； break；

       case取值2:  执行语句；break；

         …...

         default:执行语句； break；

  }

说明：1.switch语句选择的类型一般只有四种：byte，short，int， char。JDK1.5以后可以接收枚举类型，JDK1.7以后可以接收字符串。

            2.结束switch语句的两种情况：1、遇到break结束；2、执行到switch结尾结束。

            3.if和switch语句。如果判断的具体数值不多，而且符合byte  short  int  char这四种类型。建议使用switch语句，因为效率稍高。

                其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

4.函数之重载

     在同一个类中，允许存在一个以上的同名函数，只要它们的参数列表的个数或者参数类型不同即可。

      特点：与返回值类型无关，只看参数列表。

      好处：方便于阅读，优化了程序设计。

当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

5.for循环之九九乘法表

package javaBase;

/**
 * 输出99乘法表
 * 思路：使用嵌套循环
 * @author songwenju
 *
 */
public class Multiplition {
	public static void main(String[] args) {
		//控制行
		for (int i = 1; i <= 9; i++) {
			//控制列
			for (int j = 1; j <= i; j++) {
				System.out.print(j+" * "+i +" = "+ i*j +"  ");
			}
			System.out.println();
		}
	}
}

结果：

6.java的数组

   1）数组是同一种类型数据的集合。可以比喻为一个用来装数据的容器。使用数组可以自动给数组中的元素从0开始编号，方便操作这些元素。

   2）创建方式：1.int []  arr = new int [3]; 或 int arr[] = new int[3];

                             2. int []  arr = new int []{1,2,3,4,5};

                             3. int [] arr={1,2,3,4,5};

        new是用来在堆内存中产生一个容器实体。数组也被称为引用数据类型。在内存中的分配如下图：

 

3）栈和堆：

        Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

        栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

        堆内存：1、数组和对象，通过new建立的实例都存放在堆内存中。

                        2、每一个实体都有内存地址值。

                        3、实体中的变量都有默认初始化值。

                        4、实体不在被使用，会在不确定的时间内被垃圾回收器回收。

4）数组中两种异常：

1、数组脚标越界异常(ArrayIndexOutOfBoundsException)：int[] arr = new int[2]; System.out.println(arr[3]);访问到了数组中的不存在的脚标时发生。

  2、空指针异常(NullPointerException)：int[]arr = null; System.out.println(arr[0]);引用没有指向实体，却在操作实体中的元素时。

5）多维数组：

       二维数组的创建：

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

       2、 int[][] arr= new int[3][];  注：此种格式中每个一维数组都是默认初始化值null。

       3、int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//每一个一维数组中具体元素都初始化了。

      4、一种特殊定义写法：int[]x,y[]; x是一维数组，y是二维数组。

二维数组的内存分布图：

              

数组相应的典型小程序：

1、数组排序

     1)冒泡排序

package javaBase;

/**
 * 冒泡排序：
 * 思路：  1、先从头把相邻两个元素之间进行比较，将较大值存放在后一个元素中，然后再与后一个元素的进行比较，直至最大值存放到最后一个元素中。 
 *      2、再重复1操作，每次计较次数减一，一圈比完后存放的较大元素不再参与比较。
 * @author songwenju
 *
 */
public class Bubble {
	public static void main(String[] args) {
		int[] arr = {22,3,44,34,23,1,28,35};
		System.out.print("排序前：");
		//输出原数组
		printArray(arr);
		//调用排序方法
		bubbleSort(arr);
		//输出排序后的数组
		System.out.print("排序后：");
		printArray(arr);
	}
	
	/**
	 * 排序算法
	 * @param arr
	 */
	public static void bubbleSort(int[] arr){
		//把最大的冒泡出去
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j+1]) {
					//如果前一个比后一个大交换
					swap(arr, j, j+1);
				}
			}
		}
	}
	
	/**
	 * 交换元素函数
	 */
	public static void swap(int [] arr,int x,int y){
		int temp;
		temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
	/**
	 * 输出数组
	 * @param arr
	 */
	public static void printArray(int[] arr){
		for (int i : arr) {
			System.out.print(i+" ");
		}
		System.out.println();
	}
}

结果：

     2)选择排序

package javaBase;

/**
 * 选择排序：
 * 思路：  选择排序 
 *  1、先用0角标上的元素依次与其他元素进行比较，将较小值元素存放到0角标。 
 *  2、然后再拿1角标上的元素依次进行比较，以此类推。 
 * @author songwenju
 *
 */
public class SelectSort {
	public static void main(String[] args) {
		int[] arr = {22,3,44,34,23,1,28,35};
		System.out.print("排序前：");
		//输出原数组
		printArray(arr);
		//调用排序方法
		selectSort(arr);
		//输出排序后的数组
		System.out.print("排序后：");
		printArray(arr);
	}
	
	/**
	 * 排序算法
	 * @param arr
	 */
	public static void selectSort(int[] arr){
		//先假设第一个位置最小
		for (int i = 0; i < arr.length; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					//如果前一个比后一个大交换
					swap(arr, j, i);
				}
			}
		}
	}
	
	/**
	 * 交换元素函数
	 */
	public static void swap(int [] arr,int x,int y){
		int temp;
		temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
	/**
	 * 输出数组
	 * @param arr
	 */
	public static void printArray(int[] arr){
		for (int i : arr) {
			System.out.print(i+" ");
		}
		System.out.println();
	}
}

结果：

2、折半查找

package javaBase;

/**
 * 折半查找：
 * 1.比较该元素与中间位置元素的大小
 * 2.如果比中间值元素大，则将最小值变为中间值加1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复 
 * 3.如果比中间值元素小，则将最大值变为中间值减1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复 
 * @author songwenju
 *
 */
public class HalfSearch {
	public static void main(String[] args) {
		int[] arr = {2,6,9,11,15,19,22,30};  
        //打印数组  
        printArray(arr);  
        int key = 20;  
        //用第一种折半方式输出插入的角标值  
        System.out.println("当key = 20在数组arr中插入的角标位置是："+halfSearch1(arr,key));  
        key = 1;  
        //用第二种折半方式输出插入的角标值  
        System.out.println("当key = 1在数组arr中插入的角标位置是："+halfSearch2(arr,key)); 
	}
	
	 //折半查找 1
    public static int halfSearch1(int[] arr,int key)  {  
        int min = 0,max = arr.length-1,mid = (max+min)/2;  
        while(key != arr[mid]) {  
            if(min>max)  
                return min;  
            else if(key>arr[mid])  
                min = mid+1;  
            else   
                max = mid-1;  
            mid = (max+min)>>>1;//折半操作             
        }  
        return mid;   
    }  
  
    //折半查找2
    public static int halfSearch2(int[] arr,int key)  
    {  
        int min = 0,max = arr.length-1,mid;  
  
        while(min<max)  
        {  
            mid = (max+min)>>>1;//折半操作  
            if(key>arr[mid])  
                min = mid+1;  
            else if(key<arr[mid])  
                max = mid-1;  
            else  
                return mid;  
        }  
        return min;   
    }  
    
    /**
	 * 输出数组
	 * @param arr
	 */
	public static void printArray(int[] arr){
		for (int i : arr) {
			System.out.print(i+" ");
		}
		System.out.println();
	}
}

结果：

7.面向对象

1、一句话来说明面向过程与面向对象：面向过程：how to do，面向对象：who to do。

2、面向对象的理解：

   1. 是一种符合人们思考习惯的思想

   2. 可以将复杂的事情简单化

   3.将程序员从执行者转换成了指挥者

   4. 完成需求时：

         a)先要去找具有所需的功能的对象来用。

         b) 如果该对象不存在，那么创建一个具有所需功能的对象。

         c) 这样简化开发并提高复用。

3、面向对象的三个特征：

        封装（encapsulation）   继承（inheritance）   多态（polymorphism）

在Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情。设计的过程，其实就是在管理和维护对象之间的关系 。

8.对象的封装

1、封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

2、 这样做的目的：

        a）将变化隔离。

        b）便于使用。

        c）提高重用性。

        d）提高安全性。

3、 注意事项

        a)  将不需要对外提供的内容都隐藏起来。

        b)  把属性都隐藏，提供公共方法对其访问。

4、 封装的表现形式之一——private（私有）

        private关键字：权限修饰符；用于修饰类中的成员（成员变量，成员函数）；私有只在本类中有效。

       常用之一： 将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。

9.关键字this

1、this代表它所在函数所属对象的引用。简单说：哪个对象在调用this所在的函数，this就代表那个对象。

2、this的应用：

       当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

       但凡本类功能内部使用到了本类对象，都用this表示。

this语句：

       用于构造函数之间进行互相调用。如：this(name);此时this语句只能定义在构造函数的第一行。因为初始化要先执行。

对this的概括总结：

        this的两种用法：1、用于区分同名变量的情况，说的成员和局部同名的时候；2、用于构造函数间调用。

注：一般函数不能直接调用构造函数，因为this语句不能用在一般函数中，只能用在构造函数间。

10.静态方法使用时注意事项

1、静态方法只能访问静态成员。

       非静态方法既可以访问静态也可以访问非静态。

2、静态方法中不可以定义this，super关键字。

       因为静态优先于对象存在。所以静态方法中不可以出现this。

3、主方法是静态的。

------- android培训、java培训、期待与您交流！ ----------