java学习笔记

这是目录

java学习笔记

第一部分. java基础

1.1 输入输出

用户交互Scanner
用户交互Scanner进阶

1.2 基本数据类型

基本数据类型
类型转换
变量，常量，作用域
运算符
补充:包机制
补充:JavaDoc

1.3 顺序结构
1.4 循环结构

while循环
do-while循环
for循环
增强型for循环
break和continue

1.5 数组

数组定义，三种初始化及内存分析
Arrays类
稀疏数组

1.6 字符串
1.7 方法(函数)

方法的定义和调用
方法的重载
命令行传递参数
可变参数
递归

第一部分. java基础

1.1 输入输出

Scanner in=new Scanner(System.in);
int a = in.nextInt(); 
System.out.print("a的值为:"+a);
//System.out.println(); 会换行

用户交互Scanner

基本语法
```
Scanner in = new Scanner(System.in);
```
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

package com.htk.base;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收:");

        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            String str = scanner.next();
            System.out.println("输出内容为"+str);
        }
        //判断用户有没有输入字符串
        if(scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出内容为"+str);
        }
        //凡是IO流的类如果不关闭就会一直占用资源，要养成良好的习惯用完就关
        scanner.close();
    }
}

next()：

一定要读取到有效字符后才可以结束输入
对输入有效字符之前遇到空白，next()方法会自动去除（遇到空格就停止输出）
只有输入有效字符后才将其后面的空格作为分隔符或者结束符
next()不能得到带有空格的字符串

nextLine():

以Enter为结束符，返回回车之前的所有字符，可以获取空白

用户交互Scanner进阶

package com.htk.base;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        int i = 0;
        float f = 0.1f;
        System.out.println("请输入整数:");

        //判断用户有没有输入整型
        if(scanner.hasNextInt()){
             i= scanner.nextInt();
            System.out.println("输出内容为" + i);
        }else{
            System.out.println("输入的不是整数数据");
        }
        
        System.out.println("请输入浮点数:");
        //判断用户有没有输入实数
        if(scanner.hasNextFloat()){
            f= scanner.nextFloat();
            System.out.println("输出内容为" + f);
        }else{
            System.out.println("输入的不是整数数据");
        }
        
        //凡是IO流的类如果不关闭就会一直占用资源，要养成良好的习惯用完就关
        scanner.close();
    }
}

练习

题目要求:输入多个数字，并求其综合与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并执行结果

package com.htk.base;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        //和
        int sum = 0;
        //计数
        int count =0;
        //平均数
        float ave = 0.0f;
        System.out.println("请输入若干整数:");

        //判断用户有没有输入整型
        while (scanner.hasNextInt()) {
            int i = scanner.nextInt();
            sum = sum + i;
            count++;
        }
        ave = sum / count;
        System.out.println("总和为"+sum);
        System.out.println("平均数为"+ave);
        //凡是IO流的类如果不关闭就会一直占用资源，要养成良好的习惯用完就关
        scanner.close();
    }
}

1.2 基本数据类型

基本数据类型

java是强类型语言，所有变量都需要严格定义数据类型。
位（bit) 1 0 1 0的就是一位
字节（Byte）8位一字节 1B=8b
字符：指计算机中使用的字母，数字，字和符号。

基本数据类型	范围	占用字节
byte	-128 — 127	1字节
short	-32768 — 32767	2字节
int	-2147483648 — 22147483647	4字节
long	-9223372036854775808 — 9223372036854775807 后面需跟L识别	8字节
float		4字节
double		8字节
char		2字节
boolean	只有ture和false两个值	1字节

另一种数据类型叫做，引用数据类型:类，接口，数组都是这种类型

整数扩展

进制表示八进制 0 十六进制0x

//定义long变量
long a=100000000000L;

int i=10;
int j=010;
int k=0x10;
System.out.print(i); //输出10
System.out.print(j); //输出8
System.out.print(k); //输出16

浮点扩展

最好完全避免浮点数表示
BigDecimal 数学工具类，表示银行业务。

注意:比较两个浮点数

float f1=0.1f;
double f2=1.0/10;
System.out.print(f1==f2); //结果是false，是有误差的接近但不等于，最好完全避免浮点数表示
Math.abs(f1-f2)<1e-6; //浮点数计算有误差

字符扩展

字符类型可以强制转换为int型，所有的字符本质还是数字（unicode 编码表 2字节 0-65536）
转义字符

类型转换

转换优先级

byte，short，char—>int—>long—>float—>double
高到低转换时，要避免内存溢出和精读问题
不能对布尔值进行转换
不能把对象类型转换为不相干的类型

补充: JDK7新特新，数字之间可以用下滑线分割，下划线不会输出

变量，常量，作用域

变量

不建议在一行定义多个变量
每一个变量写完都要以逗号结尾
变量的命名规则(程序的可读性很重要)：
- 见名知意
- 类成员变量：首字母小写取余单词首字母大写 lastName
- 局部变量：首字母小写和驼峰原则
- 常量：均大写和下划线 PI MAX_VALUE
- 类名：首字母大写和驼峰原则 Man,GoodMan
- 方法名：首字母小写和驼峰原则 run(),runRun()

变量作用域

类变量
实例变量
局部变量

public class Demo{
    //类变量 static 从属于这个类，一起出现一起消失
    static double salary = 25000;
    //属性：变量
    
    //实例变量：从属于对象；若没有初始化，输出默认值默认值为0
    //布尔值:默认值是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;
    //main方法
    public static void main(String[] args){
        
        //局部变量:必须声明和初始值
        int i=10;
        System.out.print(i);  //输出10
        
        //变量类型 变量名字 = new Demo();
        Demo demo = new Demo();
        System.out.print(demo.age); //输出0，没有初始化，输出默认值默认值为0.
        
        //类变量 static 从属于这个类，一起出现一起消失
        System.out.print(salary)
    }
    
    //其他方法
    public void add(){
        
	}
}

常量

初始化后，不能改变值！
常量名一般使用大写字符
在变量的数据类型前加final

public class Demo{
    
   //修饰符，不存在先后判断 
   static final double PI = 3.14159;
   
	 public static void main(String[] args){
         System.out.print(PI)
	 }
}

运算符

基本运算符(operater)

算术运算符
- ```
+,-,*,/,%,++,--
```
- 整型运算如果有long则返回long，有double则返回double，其余都是返回int型
- 自增自减，++a，先++后输出；a++先输出后++
- Math 数学工具类 double pow = Math.pow(3,2)
赋值运算符
- ```
=
```
关系运算符
- ```
>,<,>=,<=,!=,==
```
逻辑运算符
- ```
&&,||,!
```
- 短路原则:
- 当使用&&时，与运算若前一项为F,则不去进行后一项的判断。
- 当使用||时，或运算时当前一项是T,的\则不去计算后一项

位运算符

```
&,|,^,~,<<,>>,>>>
```

public class Demo{
    
   //修饰符，不存在先后判断 
   static final double PI = 3.14159;
   
	 public static void main(String[] args){
         /*
         	A	= 0011 1100
         	B	= 0000 1101
         	
         	A&B	= 0000 1100
         	A|B	= 0011 1101
         	A^B	= 0011 0001
         	~B	= 1111 0010
         
         面试题:2*8这么运算最快？
         	2 = 0000 0010 
         	8 = 0000 1000 
         	我的思考是 左移一位吧，8是2的3次，再乘2就是2的4次，相当于左移一位
         	System.out.print(8<<1)
         */
	 }
}

条件运算符

// ?:
//x?y:z
//若x==ture，则结果为y，否则结果为z

扩展赋值运算符

```
+=,-=,*=,/=,%=
```
字符串连接符 +，String

public class Demo{
    
   //修饰符，不存在先后判断 
   static final double PI = 3.14159;
   
	 public static void main(String[] args){
         	int a=2;
			int b=3;
			System.out.print("String"+a+b) //后面会变成字符串链接，不会计算
			System.out.print(a+b+"String") //先运算后链接字符串
	 }
}

补充:包机制

包的本质就是文件夹（package）
包语句的语法格式为：
- ```
package pkg1[.pkg2[.pkg3]];
```
一般将公司域名倒置作为包名 com.baidu.www
导入包 import java.util.*

补充:JavaDoc

javadoc命令使用来生成自己API文档的

参数信息

/**
*@author htk
*@version 1.0
*@since 1.8
*/
public class Doc{
  	String name;
   
	 public static void main(String[] args){
         	
	 }
    // 输入/**会出现参数信息
    public String test(String name){
		return name;
    }
}

1.3 顺序结构

if - elses，switch-case需要注意的问题

//1.在if或else后面总是用{}
//2.级联if - else if - else
//3.if语句常见错误
	//1.忘记大括号
	//2.if后面有分号
	//3.错误使用==和=
//4.switch-case
/*
jdk7开始，switch支持字符串String类型
补充: java --- class(字节码文件) --- 反编译(IDEA) 每一个字符串都有一个hashcode，有个hash值
case 必须是常量或者字符串常量
*/

1.4 循环结构

//求和，求阶乘,求平均数
for(i=0;i<n;i=i+1)
{
	sum=sum+i;
	fact=fact*i;
}
ave=sum/n;
//枚举
for(one=0;i<amount;one++)
{
	for(five=0;five<amount/5;five++)
    {
    	for(ten=0;ten<amount/10;ten++)
        {
           for(twenty=0;twenty<amount/20;twenty++)
            {
                if(one+five*5+tne*10+twenty*20==amount)
                    System.out.print(one+"张1元"+five+"张5元"+tne+"张10元"+twenty+"张20元");
			} 
        }  
    }    
}

while循环

大部分情况会用一个表达式让循环停止，少部分情况需要一直执行，比如服务器请求响应。

do-while循环

一定会执行一次do里的内容。

for循环

练习1：用for循环输出1-1000之间能被5整除的数，并且每行输出3个

package com.htk.base;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {

        for(int i=1;i<=1000;i++)
        {
          if (i%5==0){
              System.out.print(i+"\t");
          }

          if(i%(5*3)==0){
              System.out.println();
          }
        }
        System.out.println();
    }
}

练习2：打印九九乘法表

package com.htk.base;

import java.util.Scanner;

public class Demo01 {
    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)+"\t\t\t");
            }
            System.out.println();
        }
        System.out.println();
        //下三角形式，小的数在前面
        for(int i=1;i<=9;i++)
        {
            for(int j=1;j<=10-i;j++)
            {
                System.out.print(i+"*"+j+"="+(i*j)+"\t\t\t");
            }
            System.out.println();
        }
    }
}

增强型for循环

jdk5引入，主要用于遍历数组和集合。

 for(int k:data){
 	System.out.println(k);
 }

break和continue

break：直接中指循环
continue：中指某一次循环

1.5 数组

数组是一种容器，特殊容器

其中所有元素都具有相同类型一旦创建无法改变。
数组大小也可以用另一种形式用number.length来确定。
for-each循环

package javaclass;

import java.util.Scanner;

public class practice {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		int i,x;
		int sum=0;
		int[] number = new int[100]; //创建数组，数组是一种容器
        //int n=in.nextInt();//输入200
        //double[] number = new double[n]; //n可以使变量,编译器检查不出下标越界运行时会抛出异常
        //数组大小也可以用另一种形式用number.length来确定。令代码具有可扩展性的代码。
        //int[] b=a;数组变量是管理者指针。两个管理者管理同一个地方。
        
        /*
        for(int k:data) //把data数组里每一个元素作为k，令其为循环的条件，适合遍历但缺少下标
        {
        	if(k==x)
        	{
        		found=ture;
			}
        }
        */
        
        //二维数组 int[][] number =new int[3][5];
        //int[][] number2 ={{1,2},{3,4,5}};
        
		x=in.nextInt();
		for(i=0;x!=-1;i++)
		{
			number[i]=x;
			sum=sum+number[i];
			x=in.nextInt();
		}
		double ave;
		ave=1.0*sum/i;
		System.out.print(sum+","+ave);
		in.close();		
	}
}

数组定义，三种初始化及内存分析

package com.htk.base;

public class Demo3 {
    public static void main(String[] args) {
        //分开写定义数组
        int[] num;
        num = new int[10];
        //合并写定义数组
        int[] num2 = new int[10];
    }
}

内存分析

java内存

堆
- 存放new的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
栈
- 存放基本变量类型(会包含这个基本变量类型的值)
- 引用对象的变量()
方法区
- 可以被所有线程共享
- 包含了所有的class和static变量
ArrayIndexOutOfBoundsException:数组下标异常

三种初始化

package com.htk.base;

public class Demo3 {
    public static void main(String[] args) {
        //静态初始化
        int[] a={1,2,3};
        //动态初始化
        int[] b=new int[10]；
        //数组默认初始化，默认值为0
        System.out.println(b[2]);  //输出为0
    }
}

Arrays类

package com.htk.base;

import java.util.Arrays;

public class Demo3 {
    public static void main(String[] args) {
        //静态初始化
        int[] a={1,4,3,8,7,9,6,2};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a))
    }
}

稀疏数组

数组中大部分为0或同一个值时，可以使用稀疏数组赖堡村改数组
处理方法
- 记录数组有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模矩阵中，从而缩小程序规模
练习:编写五子棋棋盘存盘和续盘

1.6 字符串

包裹类型:每个基础类型都有个对应的包裹类型

Boolean，Character，Integer，Double ，使用包裹类型可以调用一些方法获取信息

String

String是一个类

String s = new String("a string");
System.out.print(s.equals("a string"));   //比较字符串用equals而不是==

String操作

1.7 方法(函数)

方法是解决一类问题得步骤的有序组合
方法包含于类或是对象中
设计方法的原则：方法本意就是功能块，实现某个功能的语句块的集合。我们设计方法时，最好保持方法的原子性，就是一个方法只完成一个功能，这有利于后期扩展。

方法的定义和调用

方法的定义

修饰符 返回值类型 方法名（参数类型 参数名）{
	……
	方法体
	……
	//return 返回值；
}

修饰符:是可选的，高速编译器如何调用该方法，定义了该方法的访问类型

package com.htk.base;

public class Demo02 {
    public static void main(String[] args) {
        int max=max(10,10);
        System.out.println(max);
    }

    public static int max(int a,int b){
        if(a>b)
            return a;
        else
            return b;
    }
}

方法调用

调用方法:对象名.方法名(实参列表)
当方法返回一个值的时候，方法调用通常被当做一个值。
- ```
int max=max(20,100);
```
若方法返回值是void，方法调用一定是一条语句。
- ```
System.out.println("OK");
```
java都是值传递，不是引用传递

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数
重载的规则：
- 方法名称必须相同
- 参数列表必须不同（如个数不同，类型不同，排列不同等）
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法重载

package com.htk.base;

public class Demo02 {
    public static void main(String[] args) {
        int max=max(10,10); //方法调用
        double large=max(20.4,25.9);
        System.out.println(max);
    }
    //方法定义
    public static int max(int a,int b){
        if(a>b)
            return a;
        else
            return b;
    }
    //方法重载
    public static double max(double a,double b){
        if(a>b)
            return a;
        else
            return b;
    }
}

命令行传递参数

mian方法也可以传递参数

可变参数

jdk5后java支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号(…)
一个方法只能制定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在他之前声明。
和数组有点相似。类似于定义了一个长度位置数组参数

package com.htk.base;

public class Demo02 {
    public static void main(String[] args) {
        printMax(2,8,9,7,55,6,7,132,4,5);
        printMax(new int[] {1,2,3,4,5});
    }
    //方法定义
    public static void printMax(int...number){
        if(number.length==0){
            System.out.println("No argument passed");
            return;
        }

        int max=number[0];
        for(int i=0;i<number.length;i++)
            if(max<number[i])
                max=number[i];

        System.out.println(max);
    }
}

递归

递归就是自己调用自己。
递归函数一定要有递归出口，是有限次的。

Armorsilly

发布了137 篇原创文章 · 获赞 8 · 访问量 4271

私信关注

java学习笔记--java基础