java从入门到精通basic

1 Java开发环境+HelloWorld

dy同名: cgblpx

1.1 计算机基础知识

1.1.1 计算机

计算机（Computer）全称：电子计算机，俗称电脑。是一种能够按照程序运行，自动、高速处理数据的现代化智能电子设备。由硬件和软件所组成，没有安装任何软件的计算机称为裸机。常见的形式有台式计算机、笔记本计算机。按照规模分为微型机、小型机、大型机、巨型机（超级计算机）等。
计算机的应用已渗透到社会的各个领域，正在改变着人们的工作、学习和生活的方式，推动着社会的发展。哪些方面?

1.1.2 计算机硬件

计算机硬件（Computer Hardware）是指计算机系统中由电子，机械和光电元件等组成的各种物理装置的总称。这些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
计算机通常由CPU、主板、内存、电源、主机箱、硬盘、显卡、键盘、鼠标，显示器等多个部件组成。

1.1.3 计算机软件

计算机软件（Computer Software）是使用计算机过程中必不可少的东西，计算机软件可以使计算机按照事先预定好的顺序完成特定的功能，计算机软件按照其功能划分为系统软件与应用软件
系统软件： DOS(Disk Operating System), Windows, Linux, Unix, Mac, Android, iOS
应用软件：office QQ 英雄联盟 王者荣耀

1.1.4 软件开发

软件
按照特定顺序组织的计算机数据和指令的集合
开发
软件的制作过程
软件开发
借助开发工具与计算机语言制作软件

1.1.5 计算机语言

语言
人类进行沟通交流的各种表达符号，方便人与人之间进行沟通与信息交换
计算机语言
人与计算机之间进行信息交流沟通的一种特殊语言
计算机语言中也有字符，符号等等
常见的计算机语言如C,C++,C#,JAVA

1.1.6 人机交互方式

软件的出现实现了人与计算机之间更好的交互。
交互方式
图形化界面：这种方式简单直观，使用者易于接受，容易上手操作。
命令行方式：需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令。

1.1.7 键盘功能键及快捷键介绍

Tab
Shift Ctrl Alt
空格 Enter
Window
上下左右
PrtSc(PrintScreen)屏幕截图
Ctrl+A 全选
Ctrl+C 复制
Ctrl+V 粘贴
Ctrl+X 剪切
Ctrl+Z 撤销
Ctrl+S 保存…

1.1.8 常用的DOS命令

打开DOS控制台的方式
常用DOS命令
cmd 进入DOS窗口 #快捷方式，浏览目录，直接输入CMD跳转
默认是在c盘下，可以切换盘符。
e: 进入e盘
dir 列出当前目录下的目录和文件
mkdir 新建文件夹
rmdir 删除文件夹
cd java 进入java目录
cd … 退到上层目录
cd / 退到根目录
exit : 退出dos命令行
cls : (clear screen)清屏

1.2 Java语言概述

1.2.1 Java语言发展史

詹姆斯•高斯林（James Gosling）1977年获得了加拿大卡尔加里大 学计算机科学学士学位，1983年 获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。
后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
Java Development Kit
1.0 - 1.1 - 1.2 - 1.3 - 1.4 - 1.5
5.0 - 6.0 - 7.0 - 8.0……

Sun公司于1995年推出
1991年sun公司James Gosling等人开始开发Oak语言
1994年，将Oak语言更名为Java
1996年获得第一笔投资1亿元
1998年提出jdk1.2，更名为java2
之后推出jdk1.3 jdk1.4
2005年更名为jdk5.0，进行了大幅的版本改进
2006年sun公司宣布将Java作为免费软件对外发布
2007年3月起，全世界所有的开发人员均可对Java源代码进行修改
2007年推出jdk6.0
2009年4月Oracle以74亿美元收购了sun公司
2011年7月由Oracle正式发布jdk7
2014年3月正式发布了java8

1.2.2 Java语言平台版本

J2SE(Java 2 Platform Standard Edition)标准版
是为开发普通桌面和商务应用程序提供的解决方案，该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发。
J2ME(Java 2 Platform Micro Edition)小型版
是为开发移动设备和嵌入式设备(电器、机器人、机顶盒…)提供的解决方案。
J2EE(Java 2 Platform Enterprise Edition)企业版
是为开发企业环境下的应用程序提供的一套解决方案，该技术体系中包含的技术如 Servlet、Jsp等，主要针对于Web应用程序开发。

1.2.3 Java语言特点

简单性 高性能
编译性 解释性
面向对象 分布式处理
健壮性 安全性
开源 跨平台
什么是跨平台性？
通过Java语言编写的应用程序在不同的系统平台上都可以运行。
原理是什么？
只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。
因为有了JVM，所以同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。也称为Java具有良好的可移植性。

1.3 JDK

1.3.1 概述

JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心。
它包含了:
1、 JAVA开发工具(jdkbin)
2、 基础开发库(jdkjrelibrt.jar)
3、 基础开发库的源码(jdksrc.zip)

1.3.2 下载与安装

通过官方网站获取JDK
http://www.oracle.com
针对不同操作系统，下载不同的JDK版本
识别计算机的操作系统

下载完后进行安装，傻瓜式安装，下一步下一步即可。
注意：
1、 同时安装多个jdk时需要使用指定环境变量来确认使用的是哪个jdk
2、 安装路径不要有中文或者特殊符号如空格等。最好目录统一
3、 我们也提供了绿色解压版，不需要安装直接解压即可

1.3.3 配置环境变量

** JAVA_HOME **
该配置是要配置jdk的安装目录，来明确要使用哪个版本的jdk。
例如：我把jdk安装在了D:Javajdk7。配置如下：

** PATH **
系统会在path配置的值中，寻找可执行文件。
需要把jdkbin添加到path中。

1.3.4 目录介绍

1.4 Eclipse

1.4.1 概述

Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言,它只是一个框架和一组服务,用于通过插件组件构建开发环境。

1.4.2 下载与安装

1、 官网下载并安装
2、 下载完整的打包文件（java ee企业版），直接解压就可以用

1.4.3 工作空间workspace

用来保存所有的开发文件和代码等，也可以切换工作空间

1.5 HelloWorld案例

1.5.1 创建day01工程

1.5.2 创建包

包名全小写。
选中src-右键-new-package

1.5.3 创建HelloWorld类

类名要符合驼峰命名法。
选中包 - 右键- new-class

1.5.4 创建方法

class HelloWorld{
	public static void main(String [] args){
		System.out.println(“Hello World”);
	}
}

1.5.5 测试

直接右键run就可以

1.5.6 运行与工作原理

1、 编译：通过javac命令将java的源文件也就是.java文件编译成.class文件。
2、 执行：
先启动java虚拟机，不同的操作系统有不同的jvm，因此java跨平台。
再通过JVM加载HelloWorld.class字节码文件。并加载main方法执行程序。

1.6 拓展：

1.6.1 在自己电脑上安装jdk

同时安装两个版本，jdk1.7和jdk1.8
指定使用jdk1.8版本

1.6.2 下载最新版本eclipse

自己下载并使用

1.6.3 JDK JRE JVM的关系

1、 JDK–Java Development Kit是针对Java开发员的产品，是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。
2、 JRE–Java Runtime Environment是运行JAVA的运行时环境，包含JVM和Java核心类库。
3、 JVM–Java Virtual Machine，Java虚拟机的缩写，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。

1.6.4 Java的”一次编写，处处运行”是如何实现的？

Java程序会被编译成字节码组成的class文件，这些字节码可以运行在任何平台，因此Java是平台独立的。

2 Day02–数据类型+运算符

2.1 前言

2.1.1 标识符

可以简单的理解为一个名字。在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等。我们选择的名称就称为标识符，并且遵循以下规则：
A. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符。
B. 不能以数字开头。
C. 标识符是严格区分大小写的。
D. 标识符的命名最好能反映出其作用，做到见名知意。

2.1.2 关键字

在java语言中已经被赋予特定意义的一些单词。一共有53个关键字。其中有两个保留字:const和goto。关键字不能被用作标识符！！

2.1.3 注释

Java代码的解释说明。不影响程序的运行，用于辅助读程。
//单行注释
/* 多行注释 /
/* 文档注释 */

2.1.4 变量

在JAVA中，有的数据值是不固定的，总在变，我们还需要记录这些值，我们可以把这些值理解为变量。
我们通过三个元素来描述变量：变量类型，变量名以及变量值。
int age=18; //声明int类型的变量并赋值
String tel; //声明String类型的变量
** 注意：**
1、 变量名必须是一个有效的标识符。
2、 变量名不可以使用java关键字
3、 变量名不能重复

2.1.5 常量

在程序运行过程中一致不会改变的量成为常量。
略。。。

2.2 数据类型

2.2.1 基本类型(八种)

2.2.1.1 介绍

2.2.1.2 练习1：最大值最小值

package day0102;

public class Test1 {
	public static void main(String[] args){
		
		//=====1、整型测试开始
		byte a=-128;
		byte b=127;
		
		short c=Short.MIN_VALUE;
		short d=Short.MAX_VALUE;
		
		int e=Integer.MIN_VALUE;
		int f=Integer.MAX_VALUE;
		
		long g=Long.MIN_VALUE;
		long h=Long.MAX_VALUE;
		
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println(f);
		System.out.println(g);
		System.out.println(h);
		//=====整型测试结束
		
		//=====浮点测试开始
		float i=Float.MIN_VALUE;
		float j=Float.MAX_VALUE;
		
		double k=Double.MIN_VALUE;
		double l=Double.MAX_VALUE;
		System.out.println(i);
		System.out.println(j);
		System.out.println(k);
		System.out.println(l);
		//=====浮点测试结束
		
		//=====字符测试开始
		char a='a';
		char b=97;
		char c='b';
		char d=98;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		//=====字符测试结束

	}
}

2.2.1.3 练习2：输入个人信息

王海涛今年20岁，月薪20000，奉劝大家拼命学java，才能早日走向人生巅峰。

package day0201_规则;

import java.util.Scanner;

public class Test1_个人信息 {

	public static void main(String[] args) {
		System.out.println("姓名：");
		String name= new Scanner(System.in).nextLine();
		
		System.out.println("性別：");
		String gender= new Scanner(System.in).nextLine();
		
		System.out.println("年龄：");
		int age= new Scanner(System.in).nextInt();
		
		
		System.out.println("您输入的个人信息是：");
		System.out.println("姓名："+name);
		System.out.println("性別："+gender);
		System.out.println("年龄："+age);
		
	}
	
}

2.2.1.4 练习3：圆形面积

圆的面积：πrr
圆的周长：2πr

package day0104;

import java.util.Scanner;

public class Test1 {

	public static void main(String[] args) {
		System.out.println("请输入圆的半径");
		
		double r=new Scanner(System.in).nextDouble();
		
		System.out.println(3.14*r*r);
		
	}
}

2.2.1.5 练习4：变量交换

接收用户输入的值：假设a=1,b=2将a和b的值做交换。

package day0103;

import java.util.Scanner;


public class Test1 {

	public static void main(String[] args) {
		System.out.print("输入整数a:");
		int a=new Scanner(System.in).nextInt();
		
		System.out.print("输入整数b:");
		int b=new Scanner(System.in).nextInt();
		
		int t=a;
		a=b;
		b=t;
		System.out.println(a);
		System.out.println(b);
	}
}

2.2.2 变量练习

1. 求两个整数的和,积与平均值
2. 求长方形的周长和面积

2.2.3 引用类型

引用类型是一个对象类型，值是什么呢？它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。如：类，接口，数组,后面讲。。。

2.3 基本类型的字面值（5条）

2.3.1 整数字面值是int类型

int a = 999999999;//错，右侧是int类型，但是超出范围

2.3.2 byte，short，char三种比int小的整数可以用范围内的值直接赋值

byte b=127;//对
byte b=128;//错，右面已经超过byte范围是int类型的数据

2.3.3 浮点数的字面值是double类型

double  a=3.14;//对
float a=3.14;//错，右面是double，float是四字节double是八字节存不下

2.3.4 字面值后缀l f d

L –long 如：long a = 99999999999;//错，超出范围，解决方案加L
F –float 如：float a = 3.14;//错，右面是double类型，解决方案加F
D –double 如：double a=3;//错，右面是int，解决方案加D或者改成3.0

2.3.5 进制前缀

0x - 16进制
0 -8进制
u -char类型，16进制

2.4 基本类型的类型转换

2.4.1 小到大（隐式转换）

byte a =120;
int b=a;//直接转

2.4.2 大到小（显式转换）

需要强制类型转换

int xx = 356;
byte y=(byte) xx;

注意：小数转成整数，小数直接舍弃

2.5 运算规则（5条）

2.5.1 计算结果的数据类型，与最大类型一致

3/2   得1 ，而不是1.5，结果是int类型
3d/2  得1.5，相当于double/int，结果是double类型

2.5.2 byte,short,char三种比int小的整数，运算时会先自动转换成int

byte a=3;
byte b=4;
byte c=a+b;//错，运行时，byte会先自动转成int再运算，int+int还是int

2.5.3 整数运算溢出

整数运算，类似于一个中标，转到最大时，再转会回到最小。
计算：光速运行一年的长度是多少米

System.out.println(300000000*60*60*24*365);
System.out.println(300000000L*60*60*24*365);

2.5.4 浮点数运算不精确

java提供了解决方案，后面就会讲到。

System.out.println(1-0.8);
System.out.println(4.35*100);

2.5.5 浮点数的特殊值

Infinity 无穷大  3.14/0  
Nan  not a number  0/0.0

2.6 拓展

2.6.1 什么是显示类型转换和隐式类型转换

2.6.2 char 型变量中能不能存储一个中文汉字，为什么？

char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。

3 Day03–运算符+流程控制+循环

3.1 运算符

3.1.1 概述

3.1.2 练习1：自增自减

int a = 1;
System.out.println(a++);//先取值再自增

int b=1;
System.out.println(++b);//先自增再取值

int c=1;
int d = c++;
int e = ++c;
System.out.println(d);
System.out.println(e);

3.1.3 练习2：求三个数的最大值

package day0203_平年闰年;

import java.util.Scanner;

public class Test1_三个数的最大值 {

	public static void main(String[] args) {
		
		System.out.println("整数a:");
		int a = new Scanner(System.in).nextInt();
		
		System.out.println("整数b:");
		int b = new Scanner(System.in).nextInt();

		System.out.println("整数c:");
		int c = new Scanner(System.in).nextInt();
		
int max = a>b?a:b;
		max=max>c?max:c;

或者
int max = a>b?(a>c?a:c):(b>c?b:c);
		System.out.println(max);	
	}
}

3.1.4 练习3：平年闰年

输入年号，判断是否是闰年。两个条件：
1、能被4整除，并且不能被100整除
2、或者能被400整除

package day0203_平年闰年;

import java.util.Scanner;

public class Test1 {
	public static void main(String[] args) {
		System.out.println("年号：");
		int y = new Scanner(System.in).nextInt();
		
		String r="平年";
		if(y%4==0){
			if(y%100!=0){
				r="闰年";
			}
		}
		if(y%400==0){
			r="闰年";
		}


或者


if((y%4==0&&y%100!=0)||y%400==0){
			r="闰年";
		}

		System.out.println(y+"年是"+r);
	}
}

3.2 分支结构1：if

3.2.1 概述

顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。

3.2.2 形式

单分支：

if(判断条件){
	代码。。。
}

多分支：

if(判断条件){
	代码1。。。
}else{
	代码2。。。
}

嵌套分支：

if(判断条件1){
	代码1。。。
}else if(条件2){
	代码2。。。
} else if(判断条件3){
	代码3。。。
}else{
	代码4。。。
}

3.2.3 练习1：商品打折

接收用户输入的原价。满1000打9折。满2000打8折。满5000打5折。

package day999;

import java.util.Scanner;

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

		System.out.println("输入总原价");
		
		double price = new Scanner(System.in).nextDouble();
		double now = f(price);
		System.out.println(now);
	}
	
	public static double f(double p){
		
		if(p>5000){
			p=p*0.5;
		}else
		if(p>2000){
			p=p*0.8;
		}else if(p>1000){
			p=p*0.9;
		} 
		
		return p;
	}
	
}

3.2.4 练习2：统计学员得分

90分以上 优秀
80~89 良好
70~79 中等
60~69 及格
60分以下 不及格

package game;

import java.util.Scanner;

public class aa {
	public static void main(String[] args) {
		double score = new Scanner(System.in).nextDouble();

		if (score >= 100 || score <= 0) {
			System.out.println("请输入0~100以内的值");
		}
		if (score > 90 && score <= 100) {
			System.out.println("优秀");
		} else if (score >= 80 && score <= 90) {
			System.out.println("良好");
		} else if (score >= 70 && score <= 79) {
			System.out.println("中等");
		} else if (score >= 60 && score <= 69) {
			System.out.println("及格");
		}else if (score < 60) {
			System.out.println("不及格");
		}

	}
}

3.3 [了解] 分支结构2：switch

3.3.1 概述

当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束。

3.3.2 形式

switch(expr1)中,expr1是一个整数表达式， 整数表达式可以是int基本类型或Integer包装类型,由于byte,short,char都可以隐含转换为int，所以也支持。
注意： jdk1.7以后新增 String

switch(变量或者表达式){
	case 1:
	case 2:
	case 3:   
case 4:   
	default:
}

3.3.3 练习1：数字匹配

package day003;

import java.util.Scanner;

public class Test1_数字匹配 {

	public static void main(String[] args) {
		
		int i=3;
		switch (i) {
		case 1:
			System.out.println("1");
			break;
		case 2:
			System.out.println("2");
			break;
		case 3:
			System.out.println("3");
//			break;
		default:
			System.out.println("default");
			break;
		}
		
	}
	
}

3.4 循环结构1：for

3.4.1 概述

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
它由循环体中的条件，判断继续执行某个功能还是退出循环。
根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。

3.4.2 形式

for(开始条件；循环条件；更改条件){
	循环体代码…
}

3.4.3 练习1：打印0到10

package day999;

public class ttttt {
	public static void main(String[] args) {
		f1();
	}
	public static void f1(){
		for (int i = 0; i <= 10; i++) {
			System.out.print(i);
		}
	}
	
}

3.4.4 练习2：打印10到0

package day999;

public class ttttt {
	public static void main(String[] args) {
		f2();
	}
	public static void f2(){
		for(int i=10;i>=0;i--){
			System.out.print(i);
		}	
	}
}

3.4.5 练习3：打印8,88,888,8888

package day999;

public class ttttt {
	public static void main(String[] args) {
		f();
	}
	public static void f(){
		for(int i=8;i<=10000;i=i*10+8){
			System.out.println(i);
		}
	}
}

3.4.6 练习4：实现1~100的整数和

	int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum = sum + i;
    }
    System.out.println("sum = " + sum);

3.4.7 练习5：想打几个星星,就打几个星星

   System.out.println("你想要几个星星呀?");
   int num = new Scanner(System.in).nextInt();

   String str = "";
   for (int i = 1; i <= num; i++) {
       str = str + '*';
   }
   System.out.println(str);

3.5 拓展

3.5.1 &和&&的区别

当一个&表达式在求值的时候，两个操作数都会被求值，&&更像 是一个操作符的快捷方式。当一个&&表达式求值的时候，先计算第一个操作数，如果它返回true才会计算第二个操作数。如果第一个操作数 取值为fale,第二个操作数就不会被求值

3.5.2 a=a+4和a+=4的区别

		byte a = 1;
//		a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。
//		a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。
		a+=4;//会自动完成数据类型的转换  
		//注意：a=a+4和a+=4是有区别的！！
		System.out.println(a);

3.5.3 练习

1. 求【1,100】中，奇数的个数 和 偶数的个数
2. 求【1,100】中，奇数和 和 偶数和

4 Day04–循环+数组

4.1 嵌套for循环

4.1.1 概述

根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断。。

4.1.2 形式

for(…){
	for(…){
		
	}
}

4.1.3 入门案例

package day0000;

public class T {

	public static void main(String[] args) {
//		f1();
		f2();
	}

	//总结1：当i=1时，j取到了所有满足条件的数据，1,2,3,4,5。
	//也就是说外循环执行1次，内循环执行多次
	private static void f1() {
		for(int i=1;i<=3;i++){//外循环
			System.out.println("i="+i);//1,2,3
			for(int j=1;j<=5;j++){//内循环
				System.out.println("j="+j);//1,2,3,4,5
			}
		}
	}

//总结2：外循环控制行，内循环控制列
	private static void f2() {
		for(int i=1;i<=3;i++){
			for(int j=1;j<=5;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}

}

4.1.4 练习1：打印正方形

//正方形	
for(int i=1;i<5;i++){
	for(int j=1;j<5;j++){
		System.out.print("*");
	}
	System.out.println();
}	

4.1.5 练习2：打印左直角三角形

*
**
***
****
*****
//正直角三角形
private static void f4() {
	for (int i = 0; i < 5; i++) {//外循环，控制行，是一定的
		for (int j = 0; j <= i; j++) {//内循环，列是不固定的，是递增的
			System.out.print("*");//保证第一行打印出来一个*，注意条件
		}
		System.out.println();
	}
}

4.1.6 练习3：打印99乘法表

1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
//99乘法表
private static void f4() {
	for (int i = 1; i < 9; i++) {//外循环，控制行，是一定的
		for (int j = 1; j <= i; j++) {//内循环，列是不固定的，是递增的
			System.out.print(i+"*"+j+"="+i*j+" ");//保证第一行打印出来一个*，注意条件
		}
		System.out.println();
	}
}

4.2 break和continue

用来终止循环，可以用两种方式

4.2.1 形式

break: 中断当前循环，简单粗暴

4.2.2 练习1：找数字88

接收用户输入的100次数字，如果不是88继续输入，找到88就返回

package day003;

import java.util.Scanner;

public class Test4_breakcontinue {

	public static void main(String[] args) {
		f2();
	}

	//找88
	private static void f2() {
		for(int i=1;i<=100;i++){
			//一直输入…
			int j = new Scanner(System.in).nextInt();
			if(j!=88){
				continue;//继续输入
			}
			if(j==88){
				System.out.println("找到了88...");
				break;
			}
		}
	}
}

4.3 循环结构2：while

先判断，再执行

4.3.1 格式

while(执行条件){
	代码…
}

4.3.2 练习1：猜数字

产生一个随机数，和用户一直在输入的数字比较。

package day004;

import java.util.Random;
import java.util.Scanner;

public class Test5_猜数字 {

	public static void main(String[] args) {
		System.out.println("猜1~1000的随机数");
		//系统产生随机数，从0开始，要从1开始就加1
		int i = new Random().nextInt(1000)+1;
		System.out.println(i);
		
		while(true){
			//接收用户输入的值
			int sc = new Scanner(System.in).nextInt();
			//判断
			if(sc>i){
				System.out.println("大");
			}else if(sc<i){
				System.out.println("小");
			}else{
				System.out.println("right");
				break;
			}
		}
		
	}
	
}

4.4 循环结构3：do-while

先执行，再判断

4.4.1 格式

do{
	代码…
}while(执行条件);

4.4.1 练习1：猜数字

产生一个随机数，和用户一直在输入的数字比较。

package day004;

import java.util.Random;
import java.util.Scanner;

public class Test5_猜数字 {

	public static void main(String[] args) {
		System.out.println("猜1~1000的随机数");
		//系统产生随机数，从0开始，要从1开始就加1
		int i = new Random().nextInt(1000)+1;
		System.out.println(i);
		
		while(true){
			//接收用户输入的值
			int sc = new Scanner(System.in).nextInt();
			//判断
			if(sc>i){
				System.out.println("大");
			}else if(sc<i){
				System.out.println("小");
			}else{
				System.out.println("right");
				break;
			}
		}
		
	}
	
}

4.5 变量增强

4.5.1 概念

可以改变的数，称为变量。一般通过三部分来描述一个变量。
变量类型，变量名，变量值。其中三部分都是可以改变的，根据需要来确定即可。
变量的使用原则：就近原则。尽量控制到最小范围。。

4.5.2 局部变量

定义在方法里，或者局部代码块中。
注意：必须手动初始化，来分配内存。如：int i=5;
作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。

4.5.3 成员变量

定义在类里。
注意：不用初始化，也会自动被初始化成默认值。
作用域是整个类中，类消失了，变量才释放。
基本类型 默认值
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
boolean false

4.5.4 测试

package cn.tedu.arrays;

public class Test2_Variable {
	
	//1、成员变量：在类里方法外是
	//作用范围就是整个类里
	//可以不初始化，也会有默认值
	int age = 20;
	
	int sum = 30;
	
	public static void main(String[] args) {
		//2局部变量：在方法里是
		//作用范围就是方法里，出了这个方法就不认识了
		//必须初始化
		int sum = 10;
		System.out.println(sum);//10
		
		//3、变量的就近原则，附近有同名的会去执行最近的
		System.out.println(sum);//10
	}
}

4.6 拓展：

4.6.1 三种循环的区别

三种循环都可以互相代替
1、 for：知道循环次数
2、 while/do while：当循环次数不确定时
3、 while：先判断，不符合规则，不执行代码
4、 do while：代码最少被执行一次，再去判断，符合规则，再次执行代码

4.6.2 打印右直角三角形

    *
   **
  ***
 ****
*****


package day999;
public class a {
	public static void main(String[] args) {
		//输出5行
		for(int i=1;i<=5;i++){
			//空格三角
			for(int x=5;x>i;x--){
				System.out.print(" ");
			}
			//*号三角
			for(int j=1;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

4.6.3 打印全三角形

     *
    ***
   *****
  *******
 *********
package day999;
public class a {
	public static void main(String[] args) {
		//打印5行
		for(int i=1;i<=5;i++){
			//打印空格的倒三角
			for(int j=5;j>=i;j--){
				System.out.print(" ");
			} 
			
			//打印*号的正三角
			for(int k=1;k<=i*2-1;k++){
				System.out.print("*");
			}
			
			System.out.println();
		}
	}
}

5 Day05–方法+数组+变量

5.1 方法

5.1.1 概述

被命名的代码块，方法可以含参数可以不含参数
可以提高代码的复用性

5.1.2 形式

修饰符  返回值  方法名(【参数】){
	方法体;
}

5.1.3 练习1：方法调用

package day0203_平年闰年;

public class Test1_方法 {
	public static void main(String[] args) {

		System.out.println(1);
		f();
System.out.println(2);
	}

	private static void f() {
		System.out.println(3);//132
	}

}

5.1.4 练习2：方法参数

package day0203_平年闰年;

public class Test1_参数 {
	public static void main(String[] args) {

			System.out.println(1);
			f(2);
			System.out.println(2);
		}

	static void f(int x){
		System.out.println(x*x);//142
	}
}

5.1.5 练习3：方法返回值

package day999;

public class tt {

	public static void main(String[] args) {
		System.out.println(1);
		
		int num=f3(5);
		System.out.println(num);
		
		String str = f4("学习使我快乐");
		System.out.println(str);
		
		System.out.println(2);
	}

	public static String f4(String desc){
		return desc+",我信你个鬼";
	}
	
	
	public static int f3(int i){
		return i*10;
	}
		
}

5.2 方法的重载

5.2.1 概念

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。
程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

5.2.2 练习1：数字求和

package day005;

public class Test5_方法重载 {

	public static void main(String[] args) {
		int a=10;
		int b=20;
		String name="lisi";
		
		f1();
		f1(a);
		f1(a,b);
		f1(a,b,name);
	}

	private static void f1(int a, int b, String name) {
		System.out.println(a+b+name);//30name
	}

	private static void f1() {
		System.out.println("f1()");
	}

	private static void f1(int a) {
		System.out.println(a);
	}

	private static void f1(int a, int b) {
		System.out.println(a+b);
	}	
}

5.2.3 练习2：数据的打印

5.3 数组

5.3.1 概念

数组Array是用于储存多个相同类型数据的集合。
想要获取数组中的元素值，可以通过元素的下标来获取，下标是从0开始的。

5.3.2 创建数组

一般分为动态初始化和静态初始化
动态初始化：

int[] a = new int[5];

新建int[],长度是5
刚创建好的数组都是默认值0，int类型的数据默认值是0
把数组的地址值给变量a保存

静态初始化
方式1：int[] a ={1,2,3,4,5,6,7,8};
方式2：int[] a =new int[]{1,2,3,4,5};

5.3.3 练习1：数组中存入hello

package day004;

import java.util.Arrays;

public class Test6_数组 {

	public static void main(String[] args) {
		System.out.println("test...");
		f1();
	}

	private static void f1() {
	    int[] i = new int[]{1,2,3,4,5};
		System.out.println(Arrays.toString(i));


		char[] a = new char[5];
		a[0]='h';
		a[1]='e';
		a[2]='l';
		a[3]='l';
		a[4]='o';
		System.out.println(Arrays.toString(a));
	}
	
}

5.3.4 数组的长度

 length属性获取数组长度
 数组一旦创建，长度不可变
 允许0长度的数组

5.4 数组的遍历

从头到尾，依次访问数组的位置。

5.4.1 形式

for(int i=0;i<a.length;i++){
	syso(a[i]);
}

5.4.2 练习1：输出每个月的天数

package day004;

public class Test9_GetDay{
	public static void main(String[] args){
		int[] days=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};

		for(int i=0;i<days.length;i++){
			System.out.println((i+1)+"月有"+days[i]+"天");
		}
		
	}
}

5.4.3 练习2：遍历数组，存入1到10

package day004;

public class Test7_数组遍历 {
	public static void main(String[] args) {
		f1();
	}

	private static void f1() {
		int[] arr=new int[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i]=i+1;
			
		}
		System.out.println(Arrays.toString(arr));
	}
}

5.4.4 练习3：创建随机数组

获取100以内的随机值的数组

package com.tedu.hello;

import java.util.Arrays;
import java.util.Random;

public class t {
	public static void main(String[] args) {
		f();
	}

	private static void f() {
		int[] a = new int[5];
		
		for (int i = 0; i < a.length; i++) {
			a[i]=1+new Random().nextInt(100);
		}
		System.out.println(Arrays.toString(a));
		
	}
}

5.5 数组工具类Arrays

5.5.1 Arrays.toString(数组)

把数组里的数据，用逗号连接成一个字符串。
格式：[10, 14, 20, 46, 51]

5.5.2 Arrays.sort(数组)

对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。

5.5.3 Arrays.copyOf(数组，新的长度)

把数组复制成一个指定长度的新数组。
新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容
新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容

5.5.4 测试

int[] a = Arrays.copyOf(arr, 10);//数组的复制，大于原来长度相当于扩容
System.out.println(Arrays.toString(a));//[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]
System.out.println(a.length);//10		
int[] a2 = Arrays.copyOf(arr, 3);//数组的复制，晓宇原来长度相当于截取前几个数据
System.out.println(Arrays.toString(a2));//[12, 30, 20]
System.out.println(a2.length);//10

5.6 拓展：

5.6.1 了解二维数组

存放数组的数组，也就是说数组里存的还是数组的数据形式。

5.6.2 了解冒泡排序

冒泡最常见，也是面试中出现率最高的.
相邻位置比较，从小到大排序，如果小就往前换。i代表从头到尾遍历循环数据

package day0000;

import java.util.Arrays;
import java.util.Random;

public class TT {

	public static void main(String[] args) {
		int[] arr = new int[]{43, 36, 45, 18, 24,9,20,32};
		int[] arrnew = bubble(arr);
		System.out.println(Arrays.toString(arrnew));
	}

	private static int[] bubble(int[] a) {
		//外循环控制循环次数，如果5个数字，循环4次就行
		for (int i = 0; i < a.length-1; i++) {
			//内循环控制比大小，循环次数和外循环一样
			for (int j = 0; j < a.length-1; j++) {
				if(a[j]>a[j+1]){
					int t = a[j];
					a[j]=a[j+1];
					a[j+1]=t;
				}
			}
		}
		
		return a;
	}

5.6.3 了解二分查找算法

二分查找（Binary Search）算法，也叫折半查找算法。二分查找针对的是一个有序的数据集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0。
二分查找需要的数据必须是有序的，如果要处理的数据量很小，完全没有必要用二分查找，只有数据量比较大的时候，二分查找的优势才会比较明显。

package cn.tedu.test;

import java.util.Arrays;

public class TestBinarySearch {
    public static void main(String[] args) {
        //二分查找
        int[] a = {1,2,3,4,5,6};
        Arrays.sort(a);//先有序,再找
        System.out.println(Arrays.toString(a));

        int index = binarySearch(a, 5);//找5
        System.out.println("index = " + index);
    }
    //一次就可以砍去一半查找范围
    private static int binarySearch(int[] a, int target) {
        int low = 0;//最小下标
        int high = a.length-1;//最大下标
        while(low <= high){
            int mid = (low+high)/2; //找中间下标
            if(target == a[mid]){
                return mid;
            }else if(target > a[mid]){//目标数大,往右找
                low = mid+1; //修改low的位置
            }else if(target < a[mid]){//目标小,往左找
                high = mid - 1; //修改high的位置
            }
        }
        return -1; //没找着
    }


}

5.6.4 了解快速排序算法

5.6.5 了解其他算法

如：合并算法，快速排序等

最后

以上就是优美大门为你收集整理的java从入门到精通basic的全部内容，希望文章能够帮你解决java从入门到精通basic所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。