黑马程序员_Java基础总结

最新推荐文章于 2022-08-17 19:53:18 发布

声音的温度

最新推荐文章于 2022-08-17 19:53:18 发布

阅读量632

点赞数

本文链接：https://blog.csdn.net/u011674596/article/details/17332889

版权

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

一.Java的基础

1.java的特点

一次编译到处执行(只要你拥有.class文件就可以执行)

Java具有跨平台性，它可以在不同的系统中运行。原因是：java的运行依赖的是虚拟机(jvm)，你可以在不同的系统上装上jvm，就可以运行了。

2.doc命令中的一些常用命令

早期的编程都是通过doc系统来完成的。也就是通过一些doc命令。

下面是一些常见的命令：

cd:进入指定的目录

cd..:退回到上一级命令

dir:列出当前目录

cd/:退到根目录

md：创建目录

rd:删除目录

del：删除文件

exit：退出doc命令行。

注意：rd只能删除一层目录，也就是说如果目录中有目录的话，它不能删除

3.安装与环境搭建

要运行java程序你必须要有运行java程序的环境，所以安装软件，搭建环境是一项必须的任务：

1>安装：明确几个名词 JDK(Java Development Kit) Java开发工具包

JRE(Java Runtime Environments) Java 运行环境

JVM(Java Virtual Machine) Java 虚拟机

它们的关系是：JDK包含JRE，JRE包含JVM

　　　　　　　　　　所以你只需要安装JDK就行了

2>配置环境：

1)比较简单的一种方式

直接把JDK的安装路径复制到我的电脑——＞属性――＞高级——＞设置环境变量找到Path复制，注意用；隔开。

配置环境的一个小技巧：你可以设置一个变量来把你的JDK安装目录用这个变量来记住，然后把这个变量放到Path路径下，这样的话就不会把你Path路径下的其他路径误删了，当你需要改动时，直接改你设置的变量即可。

例如:JAVA_HOME＝" D:\jdl 1.7.7-25\bin "

Path=%JAVA_HOME%;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\

2)临时变量的配置

用命令set path例如：set path=D:\jdl 1.7.7-25\bin

还可以在原有的基础上增加一个新的值

比如：setpath=haha;%path%;

注意：如果在当前窗口你用start开启的话，它会延续原有的值，如果你从新开一个doc的话，这个值就不能用了。

二．编写java程序

1.编写程序

将java代码编写到扩展名为.java的文件中，称为源文件

2.运行程序

通过javac命令进行对java文件进行编译，通过java命令对生成的class文件进行运行。

　在任意目录下运行Java程序

　设置环境变量：setclasspath

把你的.class文件的目录设置到 classpath中，当JVM运行时它就会在你设置的目录下找。

例如：setclasspath=D:\java\day01

当你前面加上.时，它就会现在当前目录下找，如果没有找到再在指定的目录下找。

例如：setclasspath=.;D:\java\day01

3.java中的注释：

单行注释：//

多行注释：/* */

文档注释：/** */

注意：多行注释不可以嵌套多行注释

三、 Java中的基本语法

1.标识符：在程序中自定义的一些名称

规则：由数字、字母、下划线还有$符号组成，但是不能以数字开头，不能用关键字

注意：在Java中严格区分大小写

2.在Java中的名词规范：

包名：多个单词组成时，所有的字母都要小写，例如：xxxyyyzzz

类名接口名：多个单词组成时，所有的首字母都要大写，例如：AaaBbb

变量名和函数名：多个单词组成时，第一个单词首字母小写，从第二个单词开始每个单词的首字母都要大写，例如：xxxYyyZzz

常量名：所有的字母都要大写，多个单词时，每个单词用下划线连接，例如：XXX_YYY_ZZZ

注意：在起名时，为了提高代码的阅读性，尽量有意义。

3.常量：不能改变的数值

常量有：

整型常量：所有整数

小数常量：所有小数

布尔型常量：只有两个值true和false

字符常量：将一个数字字母或符号用单引号标识，例如‘a’，‘1’

字符串常量：将一个或多个字符用双引号标识

null常量：只有一个数值就是null

对于整数：Java中有三种表现形式

十进制：满10进1

八进制：满8进1 开头用0表示，每三个二进制位表示一位

十六进制：满16进1 开头用0x表示，每四个二进制位表示一位

4.进制的基本转换：

十进制转换成二进制

实际上就是对十进制数进行除2取余的运算，然后倒叙输出

例如：6转换成2进制的值为110，如下图所示：

二进制转换成十进制：实际上就是乘以2的次方的过程。

例如：110转换成10进制：1*2*2+1*2+1*0=6

二进制转换成八进制，实际上就是每三个一组，不够的补零

例如：把11010011转换成八进制为：323如下图所示：

二进制转换成十六进制,实际上就是每四个一组，不够的补零

负数的二进制的表现形式：其实就是正数取反+1，负数的最高位都是1.

5．变量：当定义变量时，会在内存中开辟空间。

Java中的数据类型如下图所示：

默认类型为int类型。Byte占8位二进制数，short占16位二进制数，int 占32位二进制数，long占64位二进制数

注意：定义变量时，不要超出你所定义的类型的范围，如果超会出现：可能损失精度

float类型的定义时，后面要写上f，例如：float=2.3f；

6.类型之间的转换：

自动类型转换：例如：byte b=3;

b=b+2; 这时会报错，因为2 为整型，在运算b=b+2;会把b自动提升为int类型的。这就是自动类型的转换。

强制类型转换：例如：byte b=(byte)(b+2);这就是强制类型的转换。我们把运算后的int类型强制转换成了byte类型。

7.运算符：

&：两边的表达式，两边都为true结果为true，有一个为false就为false

|：两边只要有一个为true，结果就为true，两边都为false才为false

^：两边相同为false，两边不同为true

！：非真为假

8. &&与&的区别

&&：两边都为true结果为true，有一个false就为false。但是与&的区别是如果左边为false，就不会运算右边而&还会运算右边。

||：当左边为true右边不运算而|两边都运算。

<<:左移相当于乘以2的移动的位数次幂

>>:右移相当于除以2的移动的位数次幂负数右移后用1不空位

>>>:无论正数和负数都补零。

位运算：&

三元运算符：格式(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；

9.判断结构：

判断语句的三种格式：

    1.if(条件表达式){执行语句；}
      2.if(条件表达式){执行语句；}
              else{ 执行语句；}
     3.if(条件表达式){执行语句；}
               else if (条件表达式){执行语句；
              else{ 执行语句；}

10.选择结构：

   格式：switch(表达式){
                         case 取值1:执行语句；break；
                            case 取值2:执行语句；break；
                                ......
                             default: 执行语句；break；}

注意：case与default直接没有顺序

当没有匹配的case时，执行default语句

Switch语句选择的类型只有四种：byte short int char

Switch语句的结束标志是break和大括号只有遇到这两种才能结束

(15)循环结构

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

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

注意：无论条件如何至少运行一次

小心do-while的条件后面有一个“；”

for(初始表达式；循环条件表达式；操作表达式){循环体}

for(;;){}:无限循环

注意：初始化表达式只读一遍

11．break和continue

break只能用于选择和循环结构。直接跳出循环

continue只能用于循环结构。结束本次循环进行下次循环

12.函数

格式：

修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，...)
{ 执行语句; return返回值; }

特点：

函数只能被调用时才执行

定义函数可以将功能进行封装，有利于对功能进行服用。

函数没有返回值时，用void表示

注意：不可以在函数内部在定义函数

如何定义一个函数呢？

有两个明确：

1> 要明确定义该功能时是否需要未知参数，这是在明确参数列表

2> 要明确该功能是否需要返回一个结果，这是在明确返回值

函数的重载：表示函数名相同函数的列表不同。

下面是一些有关重载的例子：

void show(int a,char b,double c){}

a.void show(int x,char y,double z){}//没有，因为和原函数一样。

b.int show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。

c.void show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。

d.boolean show(int c,char b){}//重载了，因为参数个数不同。

e.void show(double c){}//重载了，因为参数个数不同。

f.double show(int x,char y,double z){}//没有，这个函数不可以和给定函数同时存在与一个类中。

13.数组：同一种类型的数据集合

一维数组：

定义方式一：int[] a=new int[3];

定义方式二：int[] b={1,3,4};也可以写成：int []=new int[]{1,3,4};

数组就相当一个容器，可以用来存储数据。

二维数组：

定义方式：int[][]c=new int[3][];注意：前面的中括号必须填数。

二维数组实际上是数组中有数组。

数组的特殊写法：int[]x,y[];//x表示一维，y表示二维。

数组常见的操作问题：

空指针异常(NullPointerException)表示数组中的引用没有指向实体

数组角标越界(ArrayIndexOutOfBoundsException)访问的数组中的角标不存在，

记住：数组中的角标是从0开始的。

数组的常见操作：

主要思想是：大圈套小圈，大圈也就是指外成的循环，小圈也就是内部的循环

选择排序：从小到大

原理：就是拿第一个元素依次与后面的元素相比，找出最小值放在前面。

代码如下所示：

public class ArraySort {
	public static void main(String[] args) {
           int[] arr={2,1,5,6,7,3};
           PrintArr(arr);//打印排序前的数组
           Sort(arr);
           PrintArr(arr);//打印排序后的数组   
	}
	//对数组进行排序
	public static void Sort(int[] arr)
	{
		for(int i=0;i<arr.length;i++)
		{
			for(int j=i+1;j<arr.length;j++)
			{
		          if(arr[i]>arr[j])     
		          {
		        	  int temp=arr[i]; //交换两个值
		        	  arr[i]=arr[j];
		        	  arr[j]=temp;	  
		          }
			}
		}
	}
	//打印数组
	public static void PrintArr(int[] arr)
	{
		System.out.print("[");
		for(int i=0;i<arr.length;i++)
		{
			if(i!=arr.length-1)
				System.out.print(arr[i]+",");
			else
				System.out.println(arr[i]+"]");
		}   
	}
}

冒泡排序：

原理：就是拿第一个与第二个比较，第二个与第三个比，第三个与第四……,这样依次比。

代码如下：

public class ArraySort1 {
    public static void main(String[] args) {
       
           int[]arr={2,1,5,6,7,3};
           PrintArr(arr);
           bubbleSort (arr);
           PrintArr(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[i]>arr[j])
                 {
                     int temp=arr[i];
                     arr[i]=arr[j];
                     arr[j]=temp;   
                 }
            }
        }
    }
    public static void PrintArr(int[] arr)
    {
        System.out.print("[");
        for(int i=0;i<arr.length;i++)
        {
            if(i!=arr.length-1)
                System.out.print(arr[i]+",");
            else
                System.out.println(arr[i]+"]");
        }  
       
    }
}

折半查找：注意数组必须是有序的。

原理：取数组的中间值，如果你要找的元素比中间值小的话，就把最大值的指针挪到中间值-1，在算出中间值，如果你要找的值比中间值大的话，就把最小值的指针挪到中间值+1.依次这样循环的找。

代码如下：

public class ArraySort2 {
    public static void main(String[] args) {
           int[]arr={2,1,5,6,7,3};
PrintArr(arr);
  halfSort (arr);
             PrintArr(arr);
    }
  public static int halfSort(int[] arr,int key)
    {
          int start=0,end=arr.length,mid;
          while(start<end)
          {
              mid=(start+end)/2;
              if(key>arr[mid])
                  start=mid+1;
              else if(key<arr[mid])
                  end=mid-1;
              else
                  return mid;
          }
          return -1;
}
public static void PrintArr(int[] arr)
    {
        System.out.print("[");
        for(int i=0;i<arr.length;i++)
        {
            if(i!=arr.length-1)
                System.out.print(arr[i]+",");
            else
                System.out.println(arr[i]+"]");
        } 
    }
}

有关进制之间的转换:

原理：对于转换成二进制，取最后一位，然后向右移一位。对于转换成八进制，取最后三位，然后向右移三位，对于转换成十六进制，去最后四位，然后向右移四位。

public class ArrayDemo {
public class ArrayDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        toBin(6);
        System.out.println();
        toHex(60);
    }
    public static void toBin( int num)
    {
        chang(num,1,1);
    }
    public static void toBa( int num)
    {
        chang(num,7,3);
    }
    public static void toHex( int num)
    {
        chang(num,15,4);
    }
    public static void chang(int num,int base,int offest)
    {
        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)
        {
            inttemp=num&base;
            arr[--pos]=chs[temp];
            num=num>>>offest;
        }
        for(int i=pos;i<arr.length;i++)
        {
            System.out.print(arr[i]);
        }
    }
}

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        toBin(6);
        System.out.println();
        toHex(60);
    }
    public static void toBin( int num)
    {
        chang(num,1,1);
    }
    public static void toBa( int num)
    {
        chang(num,7,3);
    }
    public static void toHex( int num)
    {
        chang(num,15,4);
    }
    public static void chang(int num,int base,int offest)
    {
        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)
        {
            inttemp=num&base;
            arr[--pos]=chs[temp];
            num=num>>>offest;
        }
        for(int i=pos;i<arr.length;i++)
        {
            System.out.print(arr[i]);
        }
    }
}

总结： 运用查表法，因为数组的下表可以与你所求的数进行对应，这样就能得出字母A、B、C等等

心得体会：主要学习了如何配置环境，和java的一些基本的语法，以及数组的一些应用，对java有了初步的理解。

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

声音的温度

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_Java基础总结

------- android培训、java培训、期待与您交流！ ----------一.Java的基础1.java的特点一次编译到处执行(只要你拥有.class文件就可以执行)Java具有跨平台性，它可以在不同的系统中运行。原因是：java的运行依赖的是虚拟机(jvm)，你可以在不同的系统上装上jvm，就可以运行了。2.doc命令中的一些常用命令早期的编程都是通过do
复制链接

扫一扫