1.HelloWord

1.新建一个java项目

  • 文件后缀名为.java
  • Hello.java
  • 注意点系统可能没有显示后缀名,需要手动打开

2.编写代码

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}
//Hello World!

4.编译javac.java文件,会生成一个class文件

5.运行class文件,java.class文件

注意:

  1. 单词的大小写要注意:java的语法规则,对大小写敏感
  2. 尽量使用英文命名
  3. 文件名和类名必须保持一致,首字母大写
  4. 符号不能使用中文符号

2.注释、标识符、关键字

2.1注释(注释不会被执行)

在代码量、项目结构复杂时,需要用到注释

注释是给写代码的人看的

单行注释

//Hello World
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}

快捷键:CTRL+/

多行注释

注释一段文字

/*
hhhh
hhhh
hhhhh
 */
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}

文档注释

javaDoc指令

/**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception {
        return name;
    }

参数信息

@author作者名

@version版本号

@since指明最早使用的jdk版本

@param参数名

@return返回值情况

@throws异常抛出情况

2.2标识符

java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

标识符注意点

  • 所有的标识符都以字母(A-Z/a-z)、美元符$、下划线_开始
  • 首字母可以是字母(A-Z/a-z)、美元符$、下划线_或数字的任何字符组合
  • 不能使用关键字作为变量名或方法名
  • 标识符是大小写敏感的
  • 合法标识符举例:age、$salary、_value
  • 非法标识符:123abc
  • 可以使用中文拼音命名,但是不推荐,很low

3.数据类型

强类型语言:

要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用。

弱类型语言:

3.1基本类型

字节:

位(bit):计算机内部储存的最小单位,11001100是八位二进制数

字节(byte):是计算机中数据处理的基本单位,可以用B表示

1B(byte)=8bit(位)

1024B=1KB

1024KB=1MB

1024MB=1GB

字符:指计算机中使用的字母、数字、字和符号

转义字符(\t \n)空格 换行

数据类型:

整数类型:

byte

short

int

long

浮点类型:

float

特点:有限 离散 舍入误差 大约 接近但不等于

 float f = 0.1f;     //0.1
        double d = 1.0/10;    //0.1
        System.out.println(f==d);   //false
        System.out.println(f);  //0.1
        System.out.println(d);  //0.1

        float d1 = 23232322222223222f;
        float d2 = d1 + 1;
        System.out.println(d1==d2); //true

double

字符类型:

char

boolean类型

默认值为false

true

false

3.2引用类型

接口

数组

4.类型转换

java是强类型语言,有些运算需要用到类型转换

(byte、short、char、int、long、float、double)

注意点
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.把高容量转换为低容量时,强制转换
4.转换时可能存在内存溢出,或者精度问题

public class demo03 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;  //byte最大值为127,导致内存溢出
        //强制转换  (类型)变量名     高-->低
        //自动转换  低-->高

        System.out.println(i);	//128
        System.out.println(b);	//-128

5.变量、常量、作用域

5.1变量:可以变化的量

java是一种强类型语言、每个变量都必须声明其类型

java变量是程序中最基本的存储单元,包括(变量名、变量类型和作用域)

变量的命名规范:

  • 所有变量、方法、类名:见名知意
  • 类成员变量:首字母小写驼峰原则
  • 局部变量:首字母小写驼峰原则
  • 常量:大写字母和下划线
  • 类名:首字母大写驼峰原则
  • 方法名:首字母小写驼峰原则

注意:

  • 每个变量都有类型,类型可以是基本类型或引用类型
  • 变量名必须是合法的标识符
  • 变量声明是一条完整的语句,每个声明都必须以分号结束。

5.2变量作用域

类变量 static

实例变量:从属于对象,若不自行初始化,这个类型默认值;除了基本类型其余的默认值为null

局部变量:必须声明和初始化值

public class demo04 {
	static int allClicks = 0;       //类变量
    String str = "helloworld";      //实例变量
    public void method(){
        int i = 0;                  //局部变量
    }

5.3常量(关键字final)

常量:初始化后不能再改变值,不会变动的值。

常量可以理解成一种特殊的变量,值被设定后,在程序运行中不允许被改变

常量名一般用大写字符

//final 变量名=值;
        final double PI = 3.14;

final修饰符不存在先后顺序

6.运算符

  • 算术运算符:+、-、*、/、%、++、–
  • 赋值运算符:=
  • 关系运算符:> 、<、>=、<=、==、!=
  • 逻辑运算符:&&、||、!
public class demo04 {
    public static void main(String[] args) {
        //与(and)    或(or)   非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:"+(a&&b));       //逻辑与运算:两个变量都为真,结果才返回为true
        System.out.println("a || b:"+(a||b));       //逻辑或运算:其中一个变量为真,结果返回为true
        System.out.println("!(a && b)"+!(a&&b));     //逻辑非运算:如果是真,则变为假;如果是加变为真
    }

与(and) 或(or) 非(取反)

结论:

逻辑与运算:两个变量都为真,结果才返回为true

逻辑或运算:其中一个变量为真,结果返回为true

逻辑非运算:如果是真,则变为假;如果是加变为真

  • 位运算符:&、|、^、~、>>、<<、>>>(了解即可)

(>>) *2

(<<) /2

底层代码,效率很高
二进制(逢二进一)
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16

  • 条件运算符:?、:(了解即可)
  • 拓展赋值运算符:+=、-=、*=、/=(了解即可)
  • 三元运算符

x ? y : z
//如果x为true,则结果为y,否则结果为z

7.包机制

com.xx

阿里巴巴基础手册

8.流程控制

8.1Scanner对象

java.util.Scanner是java5的新特征,实现程序和人的交互

基本语法:Scanner s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串,读取前一般要使用hasNext()与hasNextLine()判断是否还有输入的数据

next():

  1. 一定要读取到有效字符后才可以结束输入
  2. 对输入有效字符之前遇到的空白,next()方法会自动将其去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  4. next()不能得到带有空格的字符串

nextLine():

  1. 以enter为结束符,nextLine()方法返回的是输入回车之前的所有字符
  2. 可以获得空白

8.2顺序结构

java的基本结构是顺序结构,一般按顺序一句一句执行

顺序结构是最简单的算法结构

顺序结构是任何一个算法都离不开的一种基本算法结构

8.3选择结构

if单选择结构

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容");
        String s = scanner.nextLine();

        if (s.equals("Hello")){
            System.out.println(s);
        }

        System.out.println("End");
        scanner.close();
    }
}

if-else双选择结构

public static void main(String[] args) {
        //考试分数大于60分为及格否则不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入考试分数");
        int score = scanner.nextInt();
        if (score >= 60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }

        scanner.close();
    }

if多选择结构

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的考试分数");

        int score = scanner.nextInt();
        if (score <= 100 && score >=90){
            System.out.println("成绩优秀");
        }else if (score <90 && score >= 70){
            System.out.println("成绩良好");
        }else  if (score < 70 && score >= 60){
            System.out.println("成绩及格");
        }else if (score < 60 && score >= 0){
            System.out.println("成绩不及格");
        }else {
            System.out.println("输入的数字有误");
        }
        scanner.close();
    }
switch多选择结构

判断一个变量与一系列值中某个值是否相等。每个值称为一个分支

8.4循环结构

while结构

最基本循环 while(布尔表达式){ //循环内容 }

只要布尔表达式为true,循环就会一直执行下去

大多数情况会让循环停止下来,需要一个让表达式来结束循环

public static void main(String[] args) {
        int num = 0;
        int sum = 0;
        while (num <= 100){
            sum = sum + num;
            num++;
        }
        System.out.println(sum);
    }

do……while结构

public static void main(String[] args) {
        int num = 0;
        int sum = 0;
        do {
            sum = sum +num;
            num++;
        }while (num <= 100);
        System.out.println(sum);
    }

do……while至少会执行一次

do{ //代码语句 }while(布尔表达式);

While和do……While区别

  • while先判断后执行,dowhile先执行后判断
  • do……while至少执行一次

for循环

for循环是支持迭代的一种通用结构,是最有效、最灵活的循环结构

语法格式:for(初始化;布尔表达式;更新){ //代码语句 }

九九乘法表

public static void main(String[] args) {

        for (int y = 1; y < 10; y++) {
            for (int x = 1;x <= y; x++){
                System.out.print(x+"*"+y+"="+(x*y)+"\t");
            }
            System.out.println();
        }
    }

增强for循环

使用重点在数组

语法格式:for(声明语句 : 表达式){ //代码句子 }

声明语句:

声明新的局部变量,该变量的类型必须和数组元素的类型匹配。作用于限定在循环语句块,值与此时数组元素的值相等

表达式:

要访问的数组名,或者是返回值为数组的方法

8.5break continue goto

break

break在任何循环语句的主体部分,均可以break控制循环的流程,break用于强行退出循环,不执行循环剩余的语句

continue

continue语句用在循环体语句中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判断。

关于goto关键字

goto关键字很早就出现在程序设计语言中,尽管goto仍是java的一个保留字,但并未在语言中正式使用;break和continue有goto的影子

9.方法

方法是语句的集合,它们在一起执行一个功能

方法是解决一类问题的步骤的有序组合

方法包含于类或对象中

方法在程序中被创建,在其他地方被引用

设计方法的原则:

方法本意是功能块,就是实现某一个功能的语句块的集合。

设计方法时,最好保持方法的原子性(一个方法只完成一个功能,利于后期的拓展)

8.1.定义:

用来完成特定功能的代码片段

语法结构:修饰符 返回值类型 方法名(参数类型 参数名)

​ {方法体 return 返回值;}

方法包含一个方法头和一个方法体

修饰符:可选的,告诉编译器如何调用该方法,定义该方法的访问类型

返回值类型:方法可能会返回值。returnValueType时方法返回值的数据类型。有些方法没看有返回值,使用关键字void

方法名:方法名和参数表共同构成方法签名

参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。值被称为实参或变量。参数列表指方法的参数类型、顺序和参数的个数。参数是可选的

  • 形式参数:在方法被调用时用于接受外界输入的数据
  • 实参:调用方法时实际传给方法的数据

方法体:包含具体的语句、定义该方法的功能

方法调用:对象名.方法名(实参列表)

当方法返回一个值时,方法调用通常被当作一个值

public static void main(String[] args) {
        int max = max(4, 3);
        System.out.println(max);
    }
    public static int max(int a,int b){
        int result = 0;
        if (a == b){
            System.out.println(result);
        }
        if (a > b){
            result = a;
        }else {
            result = b;
        }
     return result;
    }

方法的返回值是void,方法调用一定是一条语句

8.2.方法的重载

重载就是在一个类中,有相同的函数名称,但形参不同的函数。

规则:

方法名称必须相同

参数列表必须不同

方法的返回类型可以相同也可以不相同

8.3可变参数

在方法声明中,在指定参数类型后加一个省略号

一个方法中只可以指定一个可变参数,必须是方法的最后一个参数,任何普通的参数必须在他之前声明。

8.4递归

递归就是:A方法调用A方法,就是自己调用自己

结构部分:

递归头:什么时候不调用自身方法(没有头进入死循环)

递归体:什么时候需要调用自身方法

小计算可以使用

9.数组

数组是相同类型数据的有序集合

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成

每一个数据称作数组元素,每个数组元素通过一个下标来访问

9.1数组声明创建

先声明数组变量,才能在程序中使用数组

int[] num;  //定义    首选此方法

java语言使用new操作符来创建数组

num = new int[10];     //创建一个数组,存放10个int类型的数字

数组的元素是通过索引访问,数组索引从0开始

获取数组长度

array.length() 

9.2内存分析

堆:存放new的对象和数组 可以被所有的线程共享,不会存放别的对象引用

栈:存放基本变量类型(包含这个基本类型的具体数据) 引用对象的变量(会存放这个引用在堆里面的具体地址)

方法区:可以被所有的线程共享 包含所有的class和static变量

9.3三种初始化

静态初始化

//静态初始化
int[] a = {1,2,3,4,5};
System.out.println(a[0]);
//输出1

动态初始化

//动态初始化
        int[] ints = new int[10];
        ints[0] = 8;
        System.out.println(ints[0]);

数组的默认初始化

9.4数组的基本特点

  1. 数组的长度是确定的。数组一旦被创建,数组的大小不可以改变
  2. 数组的元素必须是相同类型,不允许出现混合类型
  3. 数组中的元素可以是任何数据类型,包括基本类型和引用类型
  4. 数组变量属于引用类型,数组可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

9.5数组边界

下标的合法区间:[0,length-1],越界就会报错

public static void main(String[] args){
    int[] a = new int[2];
    System.out.println(a[2]);
}

ArrayIndexOutOfBoundsException:数组下标越界异常

小结:

  • 数组是相同数据类型(数据类型可以为任意类型)的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量
  • 数组长度的确定是不可变的,不能越界

9.6多维数组

多维数组可以看成是数组的数组

二维数组就是一个特殊的一维数组

int a[][] = new int[2][5];

9.7Arrays类

数组的工具类java.utli.Arrays

由于数组对象本身没有什么方法可以调用,API中提供了一个工具类Arrays使用,可对数据对象进行一些基本操作

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法,使用的时候可以直接使用类名调用

常用功能:

  • 给数组赋值:fill方法
public static void main(String[] args) {
    int[] a = {1,2,3,4,90,909,21,23};
    Arrays.fill(a,0);   //给数组数值进行填充
        System.out.println("调用java的Arrays工具类,fill填充输出数组"+Arrays.toString(a));
    }
//输出的结果:[0, 0, 0, 0, 0, 0, 0, 0]
  • 对数组排序:sort方法,升序
public static void main(String[] args) {
    int[] a = {1,2,3,4,90,909,21,23};
    Arrays.sort(a); //数组进行排序,升序
        System.out.println("调用java的Arrays工具类,sort有序输出数组"+Arrays.toString(a));
    }
//输出的结果:[1, 2, 3, 4, 21, 23, 90, 909]
  • 比较数组:通过equals方法比较数组中元素值是否相等
  • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作

9.8冒泡排序

两层循环,外层冒泡轮数,里层依次比较

//冒泡排序(经典中的经典)
public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,4,2,7,3};
        int[] sort = sorts(a);
        System.out.println(Arrays.toString(sort));
    }
    //1.比较数组中,两个相邻的元素,若第一个数比第二个数大,交换他们位置
    //2.每一次比较,会产生一个最大的或最小的数字
    //3.下一轮会减少一次排序
    //4.依次循环
    public static int[] sorts(int[] arrays){
        //临时变量
        int temp = 0;


        //外层循环,判断要走多少次
        for (int i = 0; i < arrays.length-1; i++) {
            boolean flag = false;   //通过flag标识符减少没有意义的比较

            //内层循环,如果第一个数比第二个数大,交换位置
            for (int j = 0; j < arrays.length-1-i; j++) {
                if (arrays[j+1]<arrays[j]){
                    temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }

        }
        return arrays;
    }
}

9.9稀疏数组

编写五子棋游戏,有存盘退出和续上盘的功能

介绍:

当一个数组中大部分元素为0,或为同一值的数组时,可以使用稀疏数组来保存该数组

处理方法:

  • 记录数组共有几行几列,有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中,缩小程序的规模(压缩)

运行

  1. 创建原始数组,把最初的数组输出
  2. 程序运行之后有两个有效值,定义array1二维数组为11行11列,第一个有效值在第二行第三列值为1,第二个有效值在第三行第四列值为2
  3. 转换为稀疏数组,定义循环得到array1数组的有效值并判断数组值之间相乘为不为0(数组的默认值为0),获取有效值的个数
  4. 创建稀疏数组,将array1非0的值保存到稀疏数组中
  5. 输出稀疏数组的值
//稀疏数组
public class ArrayDemo07 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11   0:没有棋子  1:黑棋    2:白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
//        转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数:"+sum);

        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组,将非零的值,存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        System.out.println("稀疏数组");
        System.out.println("行"+"\t"+"列"+"\t"+"有效值");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]);
        }
    }
}

文章内容来源:

这是我在b站看狂神说java基础做的笔记。

原文地址:http://www.cnblogs.com/hqLGX/p/16847420.html

1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长! 2. 分享目的仅供大家学习和交流,请务用于商业用途! 3. 如果你也有好源码或者教程,可以到用户中心发布,分享有积分奖励和额外收入! 4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解! 5. 如有链接无法下载、失效或广告,请联系管理员处理! 6. 本站资源售价只是赞助,收取费用仅维持本站的日常运营所需! 7. 如遇到加密压缩包,默认解压密码为"gltf",如遇到无法解压的请联系管理员! 8. 因为资源和程序源码均为可复制品,所以不支持任何理由的退款兑现,请斟酌后支付下载 声明:如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性