java从入门到精通----基础1
1.碰到问题怎么办?
1)找同学、同桌
2)找项目经理
3)找讲师
2.学习Java的窍门?
1)多想
2)多练
3.小要求:
1)课堂气氛活跃一些
一、笔记:
1.JAVA开发环境:
1)java编译运行过程:-------------常见面试题
1.1)编译期:.java源文件，经过编译，生成.class字节码文件
1.2)运行期:JVM加载.class并运行.class
特点:跨平台、一次编程到处使用
2)名词解释:-----------------常见面试题
2.1)JVM:java虚拟机
加载.class并运行.class
2.2)JRE:java运行环境
除了包含JVM以外还包含了运行java程序所必须的环境
JRE=JVM+java系统类库(小零件)
2.3)JDK:java开发工具包
除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK=JRE+编译、运行等命令工具
说明:
2.1)运行java程序的最小环境为JRE
2.2)开发java程序的最小环境为JDK
3)配置环境变量-----------------了解
3.1)JAVA_HOME:指向jdk的安装目录
3.2)CLASSPATH:表示类的搜索路径，一般简写为.
3.3)PATH:指向jdk下的bin目录
2.Eclipse:
1)IBM、开源的、免费的、不需要安装仅需要解压即可
2)开发步骤:
2.1)新建Java项目/工程-------------------小区
2.2)新建Java包--------------------------楼号+单元号
2.3)新建Java类--------------------------房子
3)注释:解释性文本
3.1)单行注释://
3.2)多行注释:/* */
3.3)文档注释:/** */-----------------4月份
练习:
1)新建一个Java项目MyProject
2)在MyProject项目中新建包mypackage
3)在mypackage包中新建类MyClass，main中:
输出HelloWorld，并换行
4)在mypackage包中新建类Test，main中:
输出Hello，不换行
输出World，换行
输出欢迎大家，换行
输出当日事当日事毕，换行
输出...
当日事当日毕
tmooc--------------JAVA方向
1)语言基础
2)面向对象
3)API
4)数据库
5)...
每一天:
1)PPT
2)经典案例--------在Windows下配置环境变量
3)课后作业
JSD1802
day01
HelloWorld
项目 包 类
东日瑞景小区-----------2号楼4单元--------------601
工作空间：所创建的java项目的默认保存地址
/home/soft01/workspace
A:先装JDK再运行eclipse--------------正确的
B:先运行eclipse再装JDK
IBM公司用java语言开发了eclipse
让人们用eclipse开发java程序
Java: 开源的、免费的
开源(开放源代码)、免费的
PATH:/a/b;/c/d;/e/f;
javac
配置环境变量
public class HelloWorld{
public static void main(String[] args){
}
}
public class HelloWorld {
public static void main(String[] args) {
}
}
借助于开发工具-------------eclipse
JDK=JVM+java系统类库+编译、运行等命令工具
Java语言的编译运行过程:
1).java源文件，经过编译，生成.class字节码文件
2)JVM加载.class并运行.class(0和1)
假设QQ是用Java语言实现的--------只需做一套QQ
java版的QQ，经过编译，生成.class字节码文件
Windows版的JVM------------运行在Windows系统上
Linux版的JVM--------------运行在Linux系统上
IOS版的JVM----------------运行在IOS系统上
???版的JVM----------------运行在???系统上
跨平台、一次编程到处使用
C语言的编译运行过程:
.c源文件，经过编译，直接变为可执行文件(0和1)
QQ:用C语言实现的------做了好多套QQ
Windows版的QQ--------------运行在Windows操作系统上
Linux版的QQ----------------运行在Linux操作系统上
IOS版的QQ------------------运行在IOS操作系统上
???版的QQ------------------运行在???操作系统上
每个操作系统的0和1都是不一样的
Windows系统中:
你---------------01010101
Linux系统中:
你---------------10101010
IOS系统中:
你---------------11110000
用Java做了一套银行管理系统
银行------Windows、Linux、IOS
计算机只能识别0和1
我--------------01010101
和--------------10101010
你--------------00001111
Java:是一门计算机语言
任何软件都是能过语言来实现的
淘宝--------------------Java写的
京东--------------------Java写的
饿了吗------------------Java写的
摩拜--------------------Java写的
银行系统----------------Java写的
ATM系统-----------------Java写的
超市购物系统------------Java写的
Java完成20%的市场份额，但挣了整个市场80%的钱
共100个项目，共100万
其中有20个项目是用Java开发的，但挣了80万的钱
互联网发展得越好，Java只会是越来越好
这五个月之内，保证当日事当日毕
一定要保证课上的听课效率
代码绝对不是看会的，而是写会的
脑力劳动者+体力劳动者
最终拿到的工资与你平时的代码量，一定是成正比的
熟练掌握这个东西的人---------------公司所需要的
知道这个东西的人-------------------
分模块教学
语言基础(7天、练)+面向对象(10天、想)
二、回顾:
1.java开发环境:
1)编译运行过程:
1.1)编译期:.java源文件，经过编译，生成.class字节码文件
1.2)运行期:JVM加载.class并运行.class
特点:跨平台、一次编程到处使用
2)名词:
2.1)JVM:java虚拟机
加载.class并运行.class
2.2)JRE:java运行环境
JRE=JVM+java系统类库(小零件)
2.3)JDK:java开发工具包
JDK=JRE+编译、运行等命令工具
2.eclipse:
IBM、开源的、免费、仅需要解压即可
笔记:
1.变量:存数的
1)声明:
int a; //声明一个整型的变量，名为a
int b,c,d; //声明三个整型的变量，名为b,c,d
2)初始化:第一次赋值
2.1)声明的同时初始化
int a = 250; //声明整型变量a并赋值为250
2.2)先声明后初始化
int a; //声明整型变量a
a = 250; //给变量a赋值为250
3)使用:
3.1)对变量的就是对它所存的那个数的操作
int a = 5;
int b = a+10; //取出a的值5，加10后，再赋值给整型变量b
System.out.println(b); //输出变量b的值15
System.out.println("b"); //输出b，双引号中的原样输出
a = a+10; //取出a的值5，加10后，再赋值给a
//在a本身基础之上增10
System.out.println(a); //15
3.2)变量的操作必须与数据类型匹配
int a = 3.14; //编译错误，数据类型不匹配
3.3)变量在用之前必须声明并初始化
System.out.println(m); //编译错误，m未声明
int m;
System.out.println(m); //编译错误，m未初始化
4)命名:
4.1)只能包含字母、数字、_和$符，并且不能以数字开头
4.2)严格区分大小写
4.3)不能使用关键字
4.4)可以中文命名，但不建议
建议:"英文的见名知意"、"驼峰命名法"
2.基本数据类型:
1)int:整型，4个字节，-21个多亿到21个多亿
1.1)整数直接量默认为int型，不能超出范围，超出范围则编译错误
1.2)两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
1.3)整数运算时超出范围，则发生溢出(需要避免的)
2)long:长整型，8个字节，很大很大很大
2.1)长整型直接量需在数字后加L或l
2.2)运算时若有可能溢出，建议在第1个数字后加L
2.3)System.currentTimeMillis()用于获取自
1970.1.1零时到此时此刻的毫秒数-------用途下周四讲
3)double:浮点型，8个字节，很大很大很大
3.1)浮点数直接量默认为double型，表示float需在数字后加F或f
3.2)浮点型数据在运算时，有可能会出现舍入误差
4)boolean:布尔型，1个字节
4.1)只能取值为true和false
5)char:字符型，2个字节
5.1)采用的是Unicode字符集编码格式，
每个字符都有一个对应的码(0到65535之间)
表现的形式的是字符char，实质上是码int
ASCII码('a'--97 'A'--65 '0'--48)
5.2)字符直接量必须放在单引号中，只能有一个
5.3)特殊符号需通过\来转义
3.基本数据类型间的转换:
数据类型从小到大依次为:
byte,short,int,long,float,double
char
1)两种方式:
1.1)自动类型转换:从小类型到大类型
1.2)强制类型转换:从大类型到小类型
语法: (要转换成为的数据类型)变量
强转有可能会溢出或丢失精度
2)两点规则:
2.1)整数直接量可以直接赋值给byte,short,char，但不能超出范围
2.2)byte,short,char型数据参与运算时，先一律转换为int再运算
4.Scanner接收用户的输入:
1)在package下:
import java.util.Scanner;
2)在main方法中:
Scanner scan = new Scanner(System.in);
3)在第2步之下:
System.out.println("请输入年龄:");
int age = scan.nextInt();
System.out.println("请输入价格:");
double price = scan.nextDouble()
练习:-----------写在day03的包中
1)创建类AgeRange，要求:
接收用户输入的年龄age，并输出
2)创建类LeapYear，要求:
接收用户输入的年份year，并输出
3)完成课后作业第9题
4)练习今天的4段小代码---------选做
完成课后作业
给变量赋值:
1)赋一个固定的值:
int a = 5;
2)接收用户输入的值:-----------Scanner
int a = ?;
3)系统随机生成的值:-----------下周二讲
int a = ?;
byte b1 = 5;
byte b2 = 6;
byte b3 = (byte)(b1+b2);
890，打88折----------783
char ch = '\\';
System.out.println(ch); //\
0---------------0
'0'-------------48
字符char 码int
敌------------1234
军------------2234
来------------3234
袭------------4234
1234 4568 7895 4521 2357
你 过 来 这 吧
+1变为-2147483648
+1+1变为-2147483647
+1+2变为-2147483646
15206634 07311
15206634 18751
DataTypeDemo，包含main，把注释删掉
二进制:
1/10
十进制:
1/4----------------0.25
1/2----------------0.5
1/3----------------0.333333333333333333...
2/3----------------0.666666666666666666...
精确运算场合，不能使用double和float
财务ERP-----------------BigDecimal
double a=3.0,b=2.9;
System.out.println(a-b); //0.100000000000000009
//0.1
double a=6.0,b=4.9;
System.out.println(a-b); //1.099999999999999996
//1.1
1970.1.1零时到
365*24*60*60*1000--------31536000000
20亿
long a = 1000000000*2*10L;
System.out.println(a); //200亿L
溢出了
long b = 1000000000*3*10L;
System.out.println(b); //不是300亿
30亿
long c = 1000000000L*3*10;
System.out.println(c); //300亿
9223372036854775807
直接量超范围为编译错误
运算时超范围为溢出
int a = 10000000000; //编译错误
int b = 1000000000*10; //溢出
int balance = 2147483647;
balance = balance+1;
System.out.println(balance); //-2147483648
1G=1024*1024*1024字节========1073741824字节
1G=1024M(兆)
1M=1024KB(千字节)
1KB=1024B(字节)
1B=8Bit(位)
int:4个字节
long:8个字节
为什么不设计一种数据类型，然后什么都能装
更佳适用不同用户的不同的需求
别墅
四居室
三居室
两居室
一居室
开间
地下室
VarDemo
int a; //不直观
int 年龄; //直观但不专业
int nianLing; //既不直观也不专业
int age; //建议
int score,myScore,myJavaScore; //驼峰命名法
int Score,MyScore,MyJavaScore; //帕斯卡命名法(类)
HelloWorld
int a=5,b=10;
int c = a+b;
System.out.println(c); //15
早期的计算机---------算数(数字)
现在的计算机---------算数(数字、文字、图片、音频、视频等)
计算机-------输入数据+输出数据
www.taobao.com------------一个数据
淘宝首页------------------一堆数据
手机壳--------------------一个数据
一堆手机壳----------------一堆数据
详细页面------------------一堆数据
购物车--------------------一堆数据
结算----------------------一堆数据
三、
回顾:
1.变量:存数的，代词，指代的就是它所存的那个数
int a; int b,c;
int a=250; int a;a=250;
int b=a+10; System.out.println(b);
a = a+10; //在a本身基础之上增10
2.基本数据类型:
1)int:整型，4个字节，5,25,250...
2)long:长整型，8个字节，5L,25L,10000000000L...
3)double:浮点型，8个字节，3.14,25.987,0.5...
4)boolean:布尔型，1个字节，true,false
5)char:字符型，2个字节
3.基本数据类型间的转换:
1)自动类型转:小到大
强制类型转:大到小
2)short s1=5,s2-6;
short s3=(short)(s1+s2);
4.Scanner接收用户输入:
1)import java.util.Scanner;
2)Scanner scan = new Scanner(System.in);
3)System.out.println("请输入年龄:");
int age = scan.nextInt();
double price = scan.nextDouble();
笔记:
1.运算符:
1)算术:+,-,*,/,%,++,--
2)关系:>,<,>=,<=,==,!= boolean
3)逻辑:&&,||,! boolean
4)赋值:=,+=,-=,*=,/=,%=
5)字符串连接:+
6)条件/三目:boolean?数1:数2
2.分支结构:
1)if结构:1条路
2)if...else结构:2条路
3)if...else if结构:多条路------------明天讲
4)switch...case结构:多条路-----------明天讲
练习:----------------------每人两次
1)AgeRange年龄判断程序
2)LeapYear闰年判断程序
3)Cashier柜台收银程序
完成课后作业
当日事当日毕
int a=5,b=8;
int max = a>b?a:b;
if(a>b){
...
...
...
max=a;
}else{
max=b;
}
a=a+1;
a++;
++a;
a+=1;
if(boolean){
}
boolean flag = true;
if(flag){
}
int a = 5;
if(a>2){
}
int a = 5;
if(a>2 && a<8){
}
满500打8折，不满500不打折-------------if
满500打8折，不满500打9折--------------if...else
满足条件就干事，不满足条件不干事--------------if
满足条件就干事，不满足条件干另一个事------------if...else
任何复杂的程序逻辑都可以通过三种结构来实现:
1)顺序结构:从上往下逐行执行，每句必走
2)分支结构:有条件的执行某语句，并非每句必走
3)循环结构:
打8折----------------基于条件的执行
减100----------------基于条件的执行
满500打8折
满499减100
数量---------------超市购物系统(double)
---------------淘宝购物系统(int/long)
---------------股票交易系统(long)
苹果10.88一斤
半斤(0.5斤)
闰年的判断公式:
1)能被4整除，并且，不能被100整除
或者
2)能被400整除
1)year%4==0 && year%100!=0
||
2)year%400==0
(year%4==0 && year%100!=0) || year%400==0
平年------------------365天(2月28天)
闰年------------------366天(2月29天)
字符char:单引号中，只能有1个
字符串String:双引号中，0个到多个
System.out.println("HelloWorld");
18<=age<=50
age>=18
&&
age<=50
25------true
8-------false
88------false
! false true
下雨了? true false
能否结帐? true true true false
1)能微信吗? true false true false
或者--||
2)能支付宝吗? false true true false
能否毕业? false false false true
1)考试及格吗? true false false true
并且--&&
2)出勤率够80%吗? false true false true
若想干某件事是由一个条件控制的-----------------关系运算
成绩>=60
若想干某件事是由多个条件控制的-----------------逻辑运算
成绩>=60 并且 出勤率>=80%
我的年龄大于你的年龄-------------------对/错
>,<
我的体重小于或等于你的体重-------------对/错
<=,>=
我的身高等于你的身高-------------------对/错
==,!=
四、回顾:
1.运算符:
1)算术:+-*/%,++,--
2)关系:>,<,>=,<=,==,!= boolean
3)逻辑:&&,||,! boolean
4)赋值:=,+=,-=,*=,/=,%=
5)字符串连接:+
6)条件/三目:boolean?数1:数2
2.分支结构:
1)if:1条路
2)if...else:2条路
笔记:
1.分支结构:
3)if...else if结构:多条路
4)switch...case结构:多条路
优点:效率高、结构清晰
缺点:整数、相等
break:跳出switch
2.循环:反复执行一段相同或相似的代码
3.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在整个循环过程中所反复改变的那个数
4.循环结构:
1)while:先判断后执行，有可能一次都不执行
2)do...while:先执行后判断，至少执行一次
要素1与要素3相同时，首选do...while
3)for:--------------明天讲
练习:-----------------------------每人两次
1)完成ScoreLevel成绩等级判断
2)完成CommandBySwitch命令解析程序
3)完成猜数字之while版-----------一次
4)完成猜数字之do...while版
完成课后作业
当日事当日毕
Math.random()-----------0.0到0.999999999999999999...
*1000-------------------0.0到999.9999999999999999...
+1----------------------1.0到1000.999999999999999...
(int)-------------------1到1000
Math.random()-----------0.0到0.999999999999999999...
*1000-------------------0.0到999.9999999999999999...
(int)-------------------0到999
+1----------------------1到1000
循环能结束的情况:
1)循环条件为false
2)break出来的
Guessing
int num = 250;
循环变量:用户猜的那个数guess
循环三要素:
1)System.out.println("猜吧!");
int guess = scan.nextInt();
2)guess!=num
3)System.out.println("猜吧!");
guess = scan.nextInt();
猜吧!
300
太大了
猜吧!
200
太小了
猜吧!
251
太大了
猜吧!
250
恭喜你，猜对了!
案例一:
输出10次"行动是成功的阶梯"
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
循环变量:次数times
1)int times=0;
2)times<10
3)times++;
times=0/1/2/3/4/5/6/7/8/9/10时结束
案例二:
输出9的乘法表:
1*9=9
2*9=18
3*9=27
4*9=36
5*9=45
6*9=54
7*9=63
8*9=72
9*9=81
循环变量:乘数num
1)int num=1;
2)num<=9
3)num++;
num=1/2/3/4/5/6/7/8/9/10时结束
循环变量:份数times
1)int times=0;
2)times<5
3)times++;
times=0/1/2/3/4/5时结束
份数为0
够5份吗? 不够 打印一份 份数为1
够5份吗? 不够 打印一份 份数为2
够5份吗? 不够 打印一份 份数为3
够5份吗? 不够 打印一份 份数为4
够5份吗? 不够 打印一份 份数为5
够5份吗? 够了
循环变量:圈数count
1)int count=0;
2)count<3
3)count++;
count=0/1/2/3时结束
圈数为0
够3圈吗? 不够 跑一圈 圈数为1
够3圈吗? 不够 跑一圈 圈数为2
够3圈吗? 不够 跑一圈 圈数为3
够3圈吗? 够了
1)顺序结构:从上往下逐行执行，每句必走
2)分支结构:有条件的执行某语句一次，并非每句必走
3)循环结构:有条件的执行某语句多次，并非每句必走
if(boolean){ //一次
语句块
}
System.out.println("over");
while(boolean){ //多次
语句块/循环体-------------反复干的那个事
}
System.out.println("over");
if(command==1){
显示全部
}else if(command==2){
查询登录
}else if(command==0){
欢迎下次
}else{
输入错误
}
CommandBySwitch
当缺点不再是缺点的时候，就只剩优点了--------那就是首选
偶数----------------------if
闰年----------------------if
奇数、偶数----------------if...else
闰年、平年----------------if...else
正数、负数----------------if...else if
大了、小了----------------if...else if
if(score>=0 && score<=100){ //合法
if(score>=90){
System.out.println("A-优秀");
}else if(score>=80){
System.out.println("B-良好");
}else if(score>=60){
System.out.println("C-中等");
}else{
System.out.println("D-不及格");
}
}else{
System.out.println("成绩不合法");
}
A:成绩大于等于90
B:成绩大于等于80并且小于90
C:成绩大于等于60并且小于80
D:成绩小于60
int score = 45;
if(score>=90){
A-优秀
}else if(score>=80){
B-良好
}else if(score>=60){
C-中等
}else{
D-不及格
}
int score = 95;
if(score>=90){
A-优秀
}else{
if(score>=80 && score<90){
B-良好
}else{
if(score>=60 && score<80){
C-中等
}else{
if(score<60){
D-不及格
}
}
}
}
int a=8,b=5,c=2,d=3; //升序(a=2,b=5,c=8)
若a>b则交换，保证a<b
若a>c则交换，保证a<c
若a>d则交换，保证a<d
若b>c则交换，保证b<c
若b>d则交换，保证b<d
若c>d则交换，保证c<d
//若a>b则交换，保证a<b
if(a>b){
int t=a; //t=8
a=b; //a=5
b=t; //b=8
}
int t=a;a=b;b=t;
int t=b;b=a;a=t;
System.out.println("请输入两个数:");
int a = scan.nextInt();
int b = scan.nextInt();
5 6
5 6
5
6
一目:++,--,!
二目:其余都是
三目:boolean?数1:数2
五、回顾:
1.分支结构:
3)if...else if:多
4)switch...case:多
优点:效率高、结构清晰
缺点:整数(1.7开始支持String)、相等
break:跳出switch
2.循环:反复多次执行一段相同或相似的代码
3.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在循环过程中所反复改变的那个数
4.循环结构:
1)while:先判断后执行，有可能一次都不执行
2)do...while:先执行后判断，至少执行一次
要素1与要素3相同时，首选do...while
笔记:
1.循环结构:
3)for:应用率高
2.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环
3.三种循环结构的更佳适用情况:
1)while:不固定次数
要素1与要素3不同时，首选while
2)do...while:不固定次数
要素1与要素3相同时，首选do...while
3)for:应用率最高，固定次数循环
4.嵌套循环:
1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
2)执行过程:外层走一次，内层走所有次
3)建议:循环层数越少越好，能用一层就不用两层，能用两层就不用三层
若业务必须通过三层以上的循环来解决，说明你的设计有问题
4)break只能跳出一层循环
5.程序=算法+数据结构
1)算法:解决问题的流程/步骤(顺序、分支、循环)
2)数据结构:将数据按照某种特定的结构来保存
数怎么存
设计良好的/合理的数据结构会导致好的算法
6.数组:
1)是一种数据类型(引用类型)
2)相同数据类型元素的集合
3)数组的定义:
int[] arr = new int[10];
4)数组的初始化:
int[] arr = new int[3]; //0,0,0
int[] arr = {1,4,7}; //1,4,7
int[] arr = new int[]{1,4,7}; //1,4,7
int[] arr;
arr = {1,4,7}; //编译错误，此方式只能声明同时初始化
arr = new int[]{1,4,7}; //正确
5)数组的访问:
5.1)通过数组名.length来获取数组的长度(元素的个数)
int[] arr = new int[10];
System.out.println(arr.length); //10
5.2)通过下标/索引来访问元素
下标从0开始，最大到(数组的长度-1)
int[] arr = new int[3];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40; //数组下标越界异常
System.out.println(arr[arr.length-1]);
6)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i] = 100;
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
练习:----------------------每人两遍
1)完成随机加法运算器
2)完成九九乘法表
3)完成求数组元素的最大值--------day06包中
完成课后作业
当日事当日毕
int[] arr = {23,45,78,4};
找最大值的算法:
1)假设第1个元素为最大值:
int max = arr[0];
2)遍历剩余元素，将剩余元素与max比较，
若剩余元素大于max，则修改max为较大的
for(int i=1;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
}
max=23/45/78
ArrayDemo
0-------------char的默认值
'0'
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i] = 100;
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println(arr[5]);
System.out.println(arr[6]);
System.out.println(arr[7]);
System.out.println(arr[8]);
System.out.println(arr[9]);
arr[0] = 100;
arr[1] = 100;
arr[2] = 100;
arr[3] = 100;
arr[4] = 100;
arr[5] = 100;
arr[6] = 100;
arr[7] = 100;
arr[8] = 100;
arr[9] = 100;
int[] arr = new int[3]; //0,0,0
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
arr[3] = 400; //数组下标越界异常
System.out.println(arr[arr.length-1]);
arr[0]-------代表arr中的第1个元素
arr[1]-------代表arr中的第2个元素
arr[2]-------代表arr中的第3个元素
int a=0;
int b=0;
int c=0;
a=100;
b=100;
//声明整型数组arr，包含3个元素
//每个元素都是int类型，默认值为0
int[] arr = new int[3];
//声明浮点型数组d，包含10个元素
//每个元素都是double型，默认值为0.0
double[] d = new double[10];
//声明布尔型数组b，包含26个元素
//每个元素都是boolean型，默认值为false
boolean[] b = new boolean[26];
int a; //声明整型变量a
int[] a; //声明整型数组变量a
将1万本书按出版社分类存储-------------设计数据结构
找Java编程思想------------------------算法不简单
将1万本书按照图片类别分类存储---------设计数据结构
找Java编程思想------------------------算法简单
想一下子跳出多层循环，只是你自己想当然的想法
for(int i=1;i<=100;i++){
for(int j=1;j<=200;j++){
for(int k=1;k<=300;k++){
if(?){
break; //跳出k层循环
}
System.out.println("aaa");
}
}
}
---------------6000000
i=1
j=1
k走30次
j=2
k走30次
...
j=20
k走30次
20
i=2
j=1到20
...
i=10
j=1到20
\t:水平制表位，固定占8位
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
Math.random()-------------0.0到0.999999999999999...
*100----------------------0.0到99.99999999999999...
(int)---------------------0到99
int score = 0; //得分
for(int i=1;i<=10;i++){ //10次
//1.出题 2.答题 3.判题
}
System.out.println("总分为:"+score);
0到99
(1)25+5=?
算吧!
30
答对了
Addition
(2)47+8=?
算吧!
45
答错了
(3)25+5=?
算吧!
30
答对了
(4)47+8=?
算吧!
45
答错了
(5)25+5=?
算吧!
30
答对了
(6)47+8=?
算吧!
45
答错了
(7)25+5=?
算吧!
30
答对了
(8)47+8=?
算吧!
45
答错了
(9)25+5=?
算吧!
30
答对了
(10)47+8=?
算吧!
45
答错了
总分为:50
// 1 2 3
for(int times=0 ; times<10 ; times++){
System.out.println("行动是成功的阶梯"); //4.
}
System.out.println("over");
12432432432432432432432
12432432432432432432432
int times=0; //1.
while(times<10){ //2.
System.out.println("行动是成功的阶梯"); //4.
times++; //3.
}
System.out.println("over");
ForDemo
if(month==1 || month==3 || month==5 || month==7 ...){
days = 31;
}else if(month==4 || month==6 ...){
days = 30;
}else{
if(){
}else{
}
}
1/3/5/7/8/10/12----------------31天
3/6/9/11-----------------------30天
2------------------------------28天/29天
税后
五险:10%--------------1000
一金:12%--------------1200+公司1200
税--------------------325
六、回顾:
1.for:固定次数
2.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环
3.嵌套循环:
循环中套循环，外层走一次，内层走所有次
层数越少越好，break只能跳出一层循环
4.数组:
引用类型，相同数据类型元素的集合
int[] arr = new int[10];
int[] arr = {1,4,6};
int[] arr = new int[]{1,4,6};
System.out.println(arr.length); //10
arr[0] = 100;
arr[10] = 100; //数组下标越界
System.out.println(arr[arr.length-1]);
for(int i=0;i<arr.length;i++){
arr[i] = 100;
System.out.println(arr[i]);
}
笔记:
1.数组:
7)数组的复制:
7.1)System.arraycopy(a,1,a1,0,4);
7.2)int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1); //数组的扩容
8)数组的排序:
8.1)Arrays.sort(arr); //升序
8.2)冒泡排序:
8.2.1)五个数冒四轮
8.2.2)每一轮都是从第1个元素开始冒
每一次都是和它的下一个元素比
8.2.3)冒出来的就不带它玩了
2.方法:
1)封装一段特定的业务逻辑功能
2)方法尽可能的独立，只干一件事
3)方法可以被反复多次的调用
4)减少代码重复，有利于代码的维护，有利于团队的协作开发
3.方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
4.方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
5)return的用法:
1)return 值; //1.1)结束方法的执行 1.2)返回结果给调用方
2)return; //2.1)结束方法的执行
练习:-------------每人至少两次
1)将数组元素最大值放在最后一个元素的下一个位置MaxOfArray
2)冒泡排序BubbleSort
3)运行Guessing了解明天项目的需求
完成课后作业
方法可以嵌套调用
public static void main(String[] args){
say();
sayHi("zhangsan");
String n = "lisi";
sayHi(n); //String name="lisi"
double a = getNum();
System.out.println(a); //88.88
int m = plus(5,6);----------------------------实参
System.out.println(m); //11
int a=5,b=6;
int q = plus(a,b);----------------------------实参
System.out.println(q);
}
public static int plus(int a,int b){
int c = a+b;
return c;
}
public static double getNum(){
return 88.88;
}
public static void sayHi(String name){--------------形参
System.out.println("大家好，我叫"+name);
}
public static void say(){
System.out.println("大家好，我叫WKJ");
}
MethodDemo
方法可以有参与可以无参
------有参可以使方法更加灵活
System.out. println("Hello");
System. arraycopy(a,1,a1,0,4);
Arrays. sort(arr);
int[] a1 = Arrays. copyOf(a,6);----------------有参数
int a = scan. nextInt();
double b = scan. nextDouble();
double c = Math. random();-------------------无参数
double c = Math.random();
假设random()有参:
double c = Math.random(1,1000);
double c = Math.random(0,99);
double c = Math.random(1,100);
方法可以有返回值也可以没有返回值:
1)无返回值时，返回值类型设计为void
2)有返回值时，返回值类型设计为具体的数据类型即可
方法执行完后:
若后期需要用到方法中的某个数据------设计为有返回值
若后期不再需要用到方法中的某个数据----设计为无返回值
System.out.println("Hello");
System.arraycopy(a,1,a1,0,4);
Arrays.sort(arr);---------------------无返回值
int a = scan.nextInt();
double b = scan.nextDouble();
double c = Math.random();
int[] a1 = Arrays.copyOf(a,6);--------有返回值
a(){存}
b(){取}
c(){转帐}
张三--------调a()+b()+c()
李四--------调b()
王五--------调c()
赵六--------调a()+c()
main(){
调存款---------1行
调取款---------1行
调转帐---------1行
调查询余额-----1行
}
存款(){
500行
}
取款(){
500行-------------调验证密码()
}
转帐(){
1500行-------------调验证密码()
}
查询余额(){
500-------------调验证密码()
}
验证密码(){
}
B/S:浏览器/服务器
项目功能完成，交给用户--------用户不一定满意(效率的)
项目优化
代码优化
long a = System.currentTimeMillis();
复杂业务的逻辑----换了一种实现方式----换一种实现方式
long b = System.currentTimeMillis();
System.out.println(b-a); //2
int[] arr = {67,23,45,1}; //升序(1,23,45,67)
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]){
int t = arr[j];
arr[j] = arr[j+1];
arr[j+1] = t;
}
}
}
BubbleSort
i=0
j=0 67和23比，换，23,67,45,1
j=1 67和45比，换，23,45,67,1
j=2 67和1比，换，23,45,1,67-------67出来了
i=1
j=0 23和45比，不换
j=1 45和1比，换，23,1,45,67-------45出来了
i=2
j=0 23和1比，换，1,23,45,67-------23出来了
arr.length-1-i
i=0(第1轮) 比3次
i=1(第2轮) 比2次
i=2(第3轮) 比1次
第一轮:
67和23比，换，23,67,45,1
67和45比，换，23,45,67,1
67和1比，换，23,45,1,67-------------67冒出来了
第二轮:
23和45比，不换
45和1比，换，23,1,45,67-------------45冒出来了
第三轮:
23和1比，换，1,23,45,67-------------23冒出来了
1)不同的数据用不同的排序算法，优劣也是不同的
这30万个数据-----------------插入排序最快
另30万个数据-----------------冒泡排序最快
另30万个数据-----------------快速排序最快
2)有一种排序方式一直是最最快的
Arrays.sort(arr); //升序
int[] a = {10,20,30,40,50};
int[] a1 = new int[6]; //0,0,0,0,0,0
for(int i=0;i<a.length;i++){
a1[i]=a[i];
}
a1[0]=a[0];
a1[1]=a[1];
a1[2]=a[2];
a1[3]=a[3];
a1[4]=a[4];
完成一个小聊天室
int num=1;
while(num<=10){
num++;
}
System.out.println(num); //11
int num;
for(num=1;num<=10;num++){
}
System.out.println(num); //11
七、回顾:
1.数组:
1)复制:
1.1)System.arraycopy(a,1,a1,0,4);
1.2)int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
2)排序:
2.1)Arrays.sort(arr);
2.2)冒泡:
2.2.1)四个数冒三轮
2.2.2)每一轮都是从第1个元素开始，
每一次都是和它的下一个元素比
2.2.3)冒出来了就不带它玩了
2.方法:
封装特定的业务逻辑功能，一个方法只干一件事
多次调用，减少重复，便于维护、便于团队协作开发
3.方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
4.方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
方法名(有参传参);----------不建议
5.return:
1)return 值; //1.1)结束方法 1.2)返回结果给调用方
2)return; //2.1)结束方法
正课:
一.猜字符小游戏:
1.设计数据结构:变量
1)char[] chs; //随机字符数组
2)char[] input; //用户输入的字符数组
3)int[] result; //对比结果
4)int score; //得分
2.设计程序结构:方法
1)主方法:
public static void main(String[] args){
//...
}
2)生成随机字符数组chs:
public static char[] generate(){
char[] chs = new char[5];
//...
return chs;
}
3)对比:随机字符数组chs与用户输入的字符数组input
public static int[] check(char[] chs,char[] input){
int[] result = new int[2];
//...
return result;
}
3.设计算法:方法体
练习:
1.独立完成猜字符小游戏
当日事当日毕
讲语法-----------------------吃糖豆
讲项目-----------------------吃药
听得懂，就是写不出来---------------正常的
欠练
思路是学出来的，是练出来的
B:位置对个数为5
C:字符对个数为5，并且，位置对个数为5
1.藏起来一个数chs
2.猜吧!接收用户输入的数input
3.对比:
1)猜对了，则算分结束
2)猜错了，提示，并继续第2步
基本数据类型判断相等----------用==
String类型判断内容相等--------不能用==，用equals()
while(true){ //自造死循环
}
String str = scan.next(); //"ABCDE"
char[] input = str.toCharArray();
input[0]='A'
input[1]='B'
input[2]='C'
input[3]='D'
input[4]='E'
public static char[] generate(){
char[] chs = new char[5];
char[] letters = {'A','B','C','D',...,'Y','Z'};
boolean[] flags = new boolean[letters.length]; //开关数组
for(int i=0;i<chs.length;i++){
do{
int index = (int)(Math.random()*letters.length); //0到25
}while(flags[index]==true);
chs[i] = letters[index];
flags[index] = true;
}
i=0 index=0 chs[0]='A' flags[0]=true
i=1 index=25 chs[1]='Z' flags[25]=true
i=2 index=0/25/0/25/1 chs[2]='B' flags[1]=true
i=3 index=0/1/25
i=0 index=1 chs[0]='B'
i=1 index=25 chs[1]='Z'
i=2 index=1 chs[2]='B'
i=3
i=4
return chs;
}
位置对是在字符对的基础之上的
public static int[] check(char[] chs,char[] input){
int[] result = new int[2]; //0,0，假设result[0]为位置对，result[1]为字符对
for(int i=0;i<chs.length;i++){
for(int j=0;j<input.length;j++){
if(chs[i]==input[j]){ //字符对
result[1]++; //字符对个数增1
if(i==j){ //位置对
result[0]++; //位置对个数增1
}
break; //剩余input元素不再参与比较了
}
}
}
i=0
j=0 chs0-input0
j=1 chs0-input1
j=2 chs0-input2
j=3 chs0-input3
j=4 chs0-input4
i=1
j=0 chs1-input0
j=1 chs1-input1
j=2 chs1-input2
j=3 chs1-input3
j=4 chs1-input4
i=2
j=0 chs2-input0
j=1 chs2-input1
j=2 chs2-input2
j=3 chs2-input3
j=4 chs2-input4
return result;
}
Guessing
int a,b;
int[] c;
char c1,c2,c3,c4,c5;
char[] input;
小代码---------语法
经典案例-------小业务
小项目---------复杂业务(逻辑能力)
java从入门到精通----基础1相关推荐
- JAVA从入门到精通------基础篇------线程
1.什么是进程 程序是静止的,只有真正运行时的程序才能被称为进程 举个例子,我们的每一个软件就是一个进程 单核CPU在任何时间点上,只能运行一个进程,宏观并行,微观串行 2.什么是线程 线程,又称轻量 ...
- java从入门到精通_想要开始学java？你要的java从入门到精通布列如下！
java从入门到精通,让我来告诉你! 毫无疑问,java是当下最火的编程语言之一.对于许多未曾涉足计算机编程的领域「小白」来说,深入地掌握java看似是一件十分困难的事.其实,只要掌握了科学的学习方法 ...
- java从入门到精通_Java入门到精通、学习路线、就业方向、薪资及前景分析（上篇）...
今天就大家最关心的Java热门问题进行简要分析,希望能对想要学习或是正在学习Java的小伙伴能够有所帮助~(大家多多关注呦~) 一.首先我们要了解Java是什么? 好学吗? Java是一种广泛使用的计 ...
- Hive3入门至精通(基础、部署、理论、SQL、函数、运算以及性能优化)15-28章
Hive3入门至精通(基础.部署.理论.SQL.函数.运算以及性能优化)15-28章 [Hive3入门至精通(基础.部署.理论.SQL.函数.运算以及性能优化)1-14章](https://blog. ...
- Java从入门到精通十七(Stream 流)
Java从入门到精通十七(Stream 流 ) Stream 流引入说明 Stream 流的常用方法说明 1: filter() 2:collect() 3:distinct() 4:sorted() ...
- 视频教程：Java从入门到精通
<Java从入门到精通>视频教程由孙鑫老师录制(作者网站:http://www.sunxin.org),教程通俗易懂,内容全面,带领Java初学者从入门到精通,快速掌握 Java 编程语言 ...
- 详细：JAVA从入门到精通视频教程，后台学习历程
详细:JAVA从入门到精通视频教程,后台学习历程 ==基础部分 由于百度分享有时效性 想要免费资源的请加645969403 1.java基础:高琪java开发300集 链接:https://pan.b ...
- java从入门到精通第四版明日科技书籍简介及下载
Java从入门到精通(第4版)(附光盘) 平装 – 2016年10月20日 <Java从入门到精通(第4版)(附光盘)>从初学者角度出发,通过通俗易懂的语言.丰富多彩的实例,详细介绍了使用 ...
- java从入门到精通教程_Java从入门到精通小白教程
Java从入门到精通小白教程,是小编为大家找到的一套非常不错的java编程学习实战资料,是专业版的学习工具书,它的主要作用是帮助用户进行全面基础学习和进阶准备,是十分靠谱的教程!希望大家好好学习,一起 ...
最新文章
- jQuery选择器实现隔行变色和使用javaScript实现隔行变色
- Python笔记_第四篇_高阶编程_正则表达式_3.正则表达式深入
- java两个日期之间的日期_获取两个日期之间的日期形成一个集合
- GDCM：gdcm::PixelFormat的测试程序
- C++ class实现邻接矩阵存储的图(完整代码)
- Java IdentityHashMap keySet（）方法及示例
- css 图片自适应_img图片自适应object-fit
- 用 JAVA 开发游戏连连看（之四）添加更多的功能
- AutoHotkey 命令列表
- python参考手册文字版_Python参考手册(第4版)
- 新pop账户服务器信息,添加 POP 账户
- 使用Andriod Device Moniter时用正则表达式筛选指定日志
- python 波动率锥_推广 || 12个小时干货分享！上海财大期权实战特训课程（11月）...
- ubuntu挂载硬盘是什么意思
- 今日头条前端实习面试经验
- 计算机组成原理——计算机的发展历史
- 计算机基础知识操作题office2010,计算机系统操作师（中级）试题集（Office 2010版）...
- linux系统配置X11
- ISCC2014 Web（网络安全）Writeup
- 空间计量 python_【空间计量教程】空间计量及Geoda、Stata、R操作（线性回归篇）...