//谢谢杨佳名版主的提醒，我给它弄了个附件 东哥总结的基础.zip (13.17 KB, 下载次数: 100)

2014-11-18 23:35 上传

点击文件名下载附件

//介么辛苦，版主不顶置也给加个精吧，实在不行给点技术分也可以~\(≧▽≦)/~第一天:
1、学习根据,毕向东视频01
dos命令行:
dir:列出当前目录下的文件以及文件夹
md:创建目录
rd:删除目录
cd:进入指定目录
cd..:退回到上一级目录
cd/:退回到根目录
del:删除文件
exit:退出dos命令行
“d:”切换盘,盘的符号+:

在dos 命令行里删除文件(用rd),必须保证文件夹是空的
del 文件夹名 = 删除文件夹里所有文件(但是要在前1目录进行:入c:/abc/op 想删除op里的文件必须在abc这个目录下进行)

想删除当前目录先的整个类型文件:在当前文件夹中 del *.想删除文件的类型

我们的课堂以java为主!~(*^__^*)
===============
1.2
java由sun(Stanford University Netword,斯坦福大学网络公司)1995年推出
JAVAEE企业版
JAVASE标准版
JAVAME小型版
java语言编写的应用程序在不同的系统平台上都可以运行
只需要安装个JAVA虚拟机即可,有JVA(Java Virtual Machine)来负责java程序在该系统中的运行,所以java程序在windows系统,linux系统,MAC系统中都可执行
==================
1.3
JRE:java运行环境
JDK:java开发工具包 (其中包括了JRE)

简单而言:使用JDK开发完成的java程序,交给JRE去运行
JDK的官方网址www.oracle.com
            java.sun.com

cd 文件前面几个字(只要独一无二)*
就可以进入这个文件,能偷懒

电脑,高级,环境变量,path(偷懒设置,你懂得)粘贴路径,然后用分号分开
之后重新开一个dos命令行就可以生效
换目录要改
改名字要改
为了方便
动态获取某一个环境变量的值
让bin不变
如JAVA_HOME=D:\jdk1.8.0_05
%JAVA_HOME%\bin
以上属于永久配置,不修改就定型

以下为临时配置(只在当前窗口有效)
set命令
set 查看所有环境变量
set path 查看path环境变量
set path=D:\jdk1.8.0_05
那么path里面内容就改为D:\jdk1.8.0_05
set path=haha;%path%
(path里面再+个haha的内容)
===========
1.4
java程序开发体验-hello world

先写类,然后用打括号表示区间
文本文档存起来的时候,后缀要改成.java
文本这个文件叫“原文件”
需要进行翻译,即javac,编译工具
进入那个文件所在目录后,如果文件名为123.java,就打
javac 123.java
就会自动翻译出来一个新文件
之后运行
运行文件为java
class Demo
{
        public static void main(String[] args)
        {

        }        
}
上方为文件固定格式



class Demo
{
        public static void main(String[] args)
        {
                System.out.println("hello java");
        }        
}

这个格式是希望系统说 hello java

常见问题
如果翻译的时候,计算机提示
javac:找不到文件:
用法:javac< options><source files>
-help 用于列出可能的选项

则是因为两种情况
1文件名错误
2文件名正确,但是目录错了

如果用java执行的时候计算机显示
找不到或者无法加载主类
1就是名字打错了
2就是类型打错了

简便执行文件
set classpath=D:\bianchengwenjian\day01(即变成文件的地址)
设置环境变量“=”后面什么都不写的话,默认为对环境变量的清空
如 set classpath=
就是对classpath的清空

启动时候的顺序
系统先找classpath,再找当前目录
classpath=的路径,后面有“;”时,如果在classpath中没有找到文件,那么他会去当前目录找,如果没有“;”那么就不会去找当前目录

但是一般配置classpath路径后,最好别加“;”
免得乱找文件弄错

但是如果classpath需要当前路径的话,可以用“.”表示
如
classpath=.;c:\;d;\

备注,如果是可执行文件的话,用path,如果是java文件的话,用classpath
是
===========================
hello world 的小特点

class Demo
{
        public static void main(String[] args)
        {
                System.out.println("hello java");
        }        
}


class为java中的关键字(被java语言赋予特殊含义的单词),专门用于定义类
大写小写严重区分,只有小写才是关键字
Demo为类名
可以随便取,建议写一些有意义的单词
规范:类名通常有单词所组成,单词首字母通常大写,如果由多个单词组成,那么每个单词的首字母大写
public static void main(String[] args) 为主函数,写法固定,保证这个类的独立运行
打字吗的时候Tab =好多个空格

而且一个文件中可以有多个类
比如在clsaa Demo这个类型都写完之后,下面重现编写一个class Test也是可以的
翻译时候能翻译出2个文件
‘public static void main(String[] args)”不是100%的需要,只有你需要这个类运行的时候才需要打,
每个需要运行的类,都需要这个1句话(1个需要运行的类1局话即可,不需要多,也别少)

‘//’后面的东西不被翻译
“//”为单行注释

/*
床前明月光
疑是地上霜
*/
以上为多上注释

写代码的时候不要直接敲
先写注释
如:
/*
需求:定义一个hello world 程序
思路:
1.
2.
步骤:
1.class关键字定义一个类,讲代码都编写到该类中
2.为了保证该类的独立运行,在类定义个主函数,格式public static void main(String[] args)
3.保存成一个扩展名为java打的文件
4.在dos控制台中通过javac工具对java文件进行编译
5.再通过 java命令对生成的class文件进行知心。
*/
class Demo
{
        //主函数
        public static void main(String[] args)//主函数
        {
                //输出语句
                Systen.ouy,println(“hello world”)        
        }
}

===
类型名不能用关键字,如果大写的话就不是关键字了
类名数字不能开头

==================

他说太大了，超过10000字符，我分段发

第二天
学习根据,毕向东视频02

2.java语言的基础组成
2.1关键字
2.2标示符
2.3注释
2.4常亮和变量
2.5运算符
2.6语句
2.7函数
2.8组数

=====
2.1
关键字
定义:被java语言赋予了特殊含义的单词
特点:关键字中所有字母都为小写

用于定义类型的关键字:
class,interface,byte,short,int,long,float,double,char,boolean,void

用于定于数据类型值的关键字
true,false,null

用于定于流程控制的关键字
if,else,switch,case,default,while,do,for,break,continue,return

用于定义访问权限修饰符的关键字
private,portected,public

用于定义类,函数,变量修饰符的关键字
abstract,final,static,synchronized

用于定义类与类之间关系的关键字
extends,implements

用于定义建立实例及引用实例,判断实例的关键字
new,this,super,instanceof

用于异常处理的关键字
try,catch,flnally,throw,throws

用于包的关键字
package,import

其他修士符关键字
native,strictfp.transient,volatile,assert

===========================
2.2
标识符

在程序中自定义的一些名称
由26个英文字母大小写,数字:0-9 ,符号_$组成
定义合法标识符规则:
1,数字不可以开头
2,不可以使用关键字

java中严格区分大小写
注意:在起名字的时候,为了提高阅读性,要尽量有意义

java中名称的规范
包名:多单词组成时所有字母都小写
xxxyyyzzz

类名接口名:多单词组成时,所有单词的首字母大写
XxxYyyZzz

变量名和函数名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写。
xxxYyyZzz

常量名:所有字母都大写。多单词时每个单词用下划线链接。
XXX_YYY_ZZZ

======
2.3
PASS

================
2.4常量与变量

常量表示不能改变的树脂

java中常量的分类
1,整数常量,所有整数
2,小数常量,所有小数
3,布尔型常量。较为特有,只有两个数值:true false
4,字符常量,将一个数字字母或者符号用单引号(‘’)标识
5,字符串常量,将一个或者多个字符用双引号标识
6,null常量,只有一个数值就是:null

对于整数,java有三种表现形式
十进制:0-9,满10进1
八进制:0-7,满8进1,用0开头标识。
十六进制:0-9,A-F,满16进1,用0x开头表示

8个二进制代表1个字节
N多字节代表1一些数据
在计算机内存或硬盘中,存放的都是二进制数据

3个二进制代表一位,为八进制
4个二进制代表一位,为十六进制

十进制与二进制之间的转换

十进制--》二进制
原理:对十进制数进行除2运算。

如果6变成二进制
6不断除2
余数从右往左写,没有余数写0

二进制--》十进制
原理:二进制乘以2的过程

如110
0乘2的0次幂+1乘2的一次幂+1乘2的2次幂
=6


128 64 32 16 8 4 2 1
相应对应相加,如果歼灭没数,默认0,哪个有1,就+那个数
如00110101=32+16+4+1=53

128+64+32+16+8+4+2+1=255
所以一个字节最大255
=========================
其他进制转换
十进制=90
二进制=0101-1010

4个二进制=一个十六进制
0101=5  1010=10
因为16进制中没有10为A,所以1010=A
所以90对应的16进制=0x5A

转成8进制
三个二进制代表一位
01011010
前面不够拿0补
001  011  010
对应1  3   2

==================================
负数的二进制表现形式.
6=110
-6:其实就是6的二进制取反+1
取反:讲二进制1变成0变成1
6=110=0000-0000 0000-0000 0000-0000 0000-0110
  取反=1111-1111 1111-1111 1111-1111 1111-1001
再+1 ,1= 0000-0000 0000-0000 0000-0000 0000-0001
上下相加 1111-1111 1111-1111 1111-1111 1111-1010=-6

负数的二进制的最高位都是1
整数的二进制的最高位都是0

=====================
2.4变量
变量:就是讲不确定的数据记性存储
     也就是需要在内存中开辟一个空间。
如果开辟空间呢?
就是通过明确数据类型,变量名称数据来完成。

名称:变量名
空间的类型:数据类型

java语言是强烈型语言,对于每一种数据都定义了明确的具体数据类型,在内存总分配了不同大小的内存空间
数据类型:
一基本数据类型:
1数字型:整数类型(byte,short,mt,long)
             浮点类型(float,double)
2字符型:char
3布尔型:boolean
二引用数据类型
1类(class)
2接口(interface)
3数组([])
整数默认:int 小数默认:double

定义变量的格式:
数据类型  变量名 = 初始化值; (不要忘记分号)

如,定义一个int类型的变量,取值为4
int x = 4 ;   (X是变量名,看情况取,也可随意取)
如果要换数据,比如吧4换成10只需要打
x = 10就可以了


int x = 4;
System.out.println("x");
x=10
System.out.println("x");

这样可以同时打出4和10

byte b = 2;  (取值范围为-128-127;如果超出这个范围,系统会说可能损失精度)

short 最大范围32767

long l = 4l;
float f =2.3f;
double d = 34.56;

char ch = ‘4’;
char ch1 = 'a';
char ch2 = ‘+’;
char ch3 = ‘ ’;
空格也是字符   


boolean bo = true ;
boolean bo1 = false ;

什么时候定义变量?
当数据不确定的时候,需要对数据进行存储的时候
就定义一个变量来完成存储动作

int a = 5
a = a + 6

===============
类型的转换

byte b = 3;
b = b + 2;

System.out.println(b);
欲出结果,但是不行

因为b占1个八位,2占4个八位

需要自动类型提升

如果非要吧b+2的值赋给B

需要 强制转换
如b= (byte)(b+2);

System.out.println((char)(‘a’+1));
把a+1的结果有数字强制性转换成字母
ascil码表中同一个字母大小写对应字母不同
字符数字和纯数字对应的也不同
比如‘1’个1对应数字不同


===================================
运算符

陷阱
int x = 4270
x = x/1000*1000;
System.out.println(x)

因为4270先除以1000=4.270
但是int 形只保留整数,所以=4
然后4*1000=4000
输出结果为4000

%=去模,(余数)
如System.out.println(10%4)
            = 2

5%1=0

1%5=5

规律,左边小于右边=左边
左边=右边结果=0
右边是1,结果=0

如果出现负数只看左边
-1%5=-1
1%-5=1

++ 自增

int a = 3,b; (a被赋予3,b还没被赋予值)

b = a++;
System.out.println(b)
System.out.println(a)

结果b=3 a=4
a++的意思是 a =a+1;
++每次只自增1

b = a++;
的意思是,a的值先给b,然后本身+1
b = ++a;的意思是,本身先+1,然后给b

b = ++a; 的值b=4 a=4

所以无论是++a 还是 a++
这道题中b的指都=4

如果加好用在字符串中,叫做字符串连接符

如“hahahahahhahahahah”一行写不下了
可以写“hahahaha”+”hahahaha”
字符串数据和任何数据使用+都是想链接,最终都会变成字符串。

如System.out.println(”ab”+5+5);则 结果会变成“ab55”
如果想要让ab和10做链接,则System.out.println(“ab”+(55))
提高优先级则可

System.out.println(“a=”+a,"b=”+b)
输出结果就是a=a的数值,b=b的数值
(为了清除建议以后就这么打)

“ln”代表换行
如果System.out.println(“hello world”)
System.out.println(“hello java”)
显示出来的是
hello world
hello java
如果System.out.print(hello world)
System.out.println(hello java)
显示出来的就是hello worldhellojava

转义字符:通过\ 来转变后面字母或者符号的含义

\n:换行
\b:退格。相当于backspace
\r:按下回车键。windows系统中,回车符是有2个字符来表示\r\n
\t:制表符。相当于tab键

如System.out.println(“hello \n world”)
法医出来就为
hello
world

System.out.println(“\“hello”\”)
输出语句就是“hello”
\能改变含义
\“\”

System.out.println(“\\hello\\”)
出来就是\hello\

一个汉字是2个字节
char 也2个字节
char c =‘你’
也可以出来的


+=  -=  *= /=  %=  这些都是1个运算符
x+=4;相当于 x = x +4

但是x+=4和x = x + 4 的最大区别是
x+=4会做自动转换 而 x = x + 4 不会
从而
short s =4
s = s + 5编译失败(因为S会被提升为int类型,运损后的结果还是int类型。无法赋值给short类型,容易丢失精度)
s+=5 编译不会失败(只做赋值运算,自动完成了强制转换的操作)

int a,b,c; (同时定义abc)
a=b=c=5 (同时赋值为5)

===================================
比较运算符
<=(小于等于)
>=(大于等于)
!=(不等于)
false (错误)
true(正确)

== 比较运算符
特点:运算为结果要不真要不假

System.out.println(3>4)
退出结果
false (错误)

System.out.println(3==4)
推出结果
false

=====================
逻辑运算符
& 与
| 或
^ 异或
!非
&& 和(短路)
||或(短路)

逻辑运算符用于连接boolean类型的表达式

如 int x = 4
x>3 & x<6 = true & true = true;

true & true = true;
true & false = false;
false & true = false;
false & false = false;

&:只要两边的boolean表达式结果,有一个为false,那么结果就是false
  只有两边都为true,结果为true

true | true = true;
true | false = true;
false | false = false;
|:只要两边有一个true ,结果为true
  只有两边都为false结果为false

true ^ true = false;
true ^ false = false;
false ^ true = false;
false ^ false = false;
^:异或,就是和|有点不一样,当true ^ true = false
^: 两边都相同结果是false
   两边不同结果是true.
如果 int a = 2
a>3 && a<6
如果左边假,右边不运算,直接出假
左边真,右边才开始运算

&&和&的特点
&:无论左边是trun是false,右边都运算
&&:当左边是false时,右边不运算
所以&&比&运算效率高一点

||和|的特点
|:两边都参与运算
||:当左边为true,右边不运算

===============================
位运算符

<<左移

3<<2;
即二进制左移
原先的3二进制   0000-0000 0000-0000 0000-0000 0000-0011
左移2位后       0000-0000 0000-0000 0000-0000 0000-1100
所以3《2=12

>>右移

6>>2
原先6的二进制  0000-0000 0000-0000 0000-0000 0000-0110
向右移两位后   0000-0000 0000-0000 0000-0000 0000-0001
所以6>>2 =1

左移:一个数乘以2移动的位数次幂
3<<2=12(3*4=12) ;3<<1=6(3*1=6);3<<3=24(3*8=24)

右移:其实就是除以2的移动位数次幂

右移,如果是负数的话,前面补的是1

>>>(三个大于右移)
不管是正是负,最高位都是0补(无论最高位是什么,右移后都用0补)  

>>:z最高位补什么由原有数据的最高位值而定。
   如果最高位是0,右移后,用0补空位
   如果最高位1,有以后用1补空位
----
&也可以作为位运算存在

System.out.println(6 & 3)

6 & 3
110&011 规律,0视为假,1视为真
所以110&011结果为010 =2
所以6 & 3 =2

6|5
110
|101
-----
111

所以6|5 =7


6^5

110
^101
--------
011

6^5=3
一个数异或同一个数两次,结果还是那个数如(7^4^4=1)
实际作用:加密
比如7^4,就看不到7了,加密了,看不到原先数据
然后再^4就解密可以看到原信息了


~反码
比如0000-0000 0000-0000 0000-0000 0000-0110  结果是6
反码1111-1111 1111-1111 1111-1111 1111-1001   结果是-7

所以~6=-7

=================================
练习
1.最有效的方式算出2乘以8等于几?
答案2<<3  (位运算比2*8快)

2.对两个整数变量的值进行互换(不需要第三方变量)


int n =3 ,m = 8;
System.out.println(“n=”+n,“m=”+m)

1,通过第三方变量的情况
;
int temp;
temp = n;
n=m;
m=temp

2,不用第三方变量。
n = n + m;(如果n和m的值非常大,容易超出int范围)
m = n - m;
n = n - m;
(实际结果11=3+8
         3=11-8
         8=11-3)


3,不用第三方变量的第二种方法
n = n ^ m;
m = n ^ m;  //(n^m)^m;
n = n ^ m;   //n^(n^m)

这种方式不涉及到超出范围的运算,是设计技巧型的方式

但是真正实际开发时候用第一种
.
===================

0000-0000 0000-0000 0100-1100 1110-0110
如果有取最低四位的话  
   0000-0000 0000-0000 0000-1100 1110-0110                          
&  0000-0000 0000-0000 0000-0000 0000-1111
---------------------------------------------
   0000-0000 0000-0000 0000-0000 0000-0110
这样就去到最低四位

这样60&15=12

如果要去下4位
那么

temp=60>>4
temp & 15=
   0000-0000 0000-0000 0000-0000 0000-0100
&  0000-0000 0000-0000 0000-0000 0000-1111
-------------------------------------------
   0000-0000 0000-0000 0000-0000 0000-0100

所有60>>4后&5的结果等于8

综上所述,
int num = 60
获取60的最低四位,通过&15;
num & 15 =12;

要获取下一组四位,讲60左移4位
int temp = 60 >>> 4;

对temp的值进行最低四位的获取
temp & 15 =3;

asilc标

0-9 ‘A’‘B’‘C’‘D’‘E’‘F’
      65   66   67
      10   11   12  13  14  15
12 - 10 = 2 + ‘A’ = (char)67

所以想要转换成16进制的话就接着打
System.out.println((char)(n1-10+‘A’))

=================
三元运算符

格式
(条件表达式)?表达式1:表达式2;
如果条件为true ,运算后的结果是表达式1:
如果条件为false,运算后的结果是表达式2:
示例:
获取两个数中最大数
int x=3,y=4,z;
z = (x>y)?x:y;//z变量储存的就是两个数的大数。

比如
int x =3,y;
y = (x>1)?100:200;
system.out.println(“y=”+y)

(意思,如果X大于1就100,Y小于等于1就显示200)

所以上方的式子该这样写
int num =60;
int n1 =num & 15;
System.out.println(n1>9?(char)(n1-10+‘A’):n1);

然后再获取以一组4位
int temp = 60 >>> 4;

int n2 = temp & 15;
System.out.println(n2>9?(char)(n1-10+‘A’):n2);

(目前有些强转问题,这些代码还是失败的,以后会学到如何改进,大致就这么意思)
(毕老师又偷懒了= =)

=========================
2.6程序流程控制
判断结构
if语句
三种格式
1.
if(条件表达式)
{
        执行语句;
}
---------------
2
if(条件表达式)
{
        执行语句;
}
else
{
        执行语句
}
----------------------
3
if(条件表达式)
{
        执行语句;
}
else if (条件表达式)
{
        执行语句
}
....
else
{
        执行语句
}

=================
例:
第一种
int x = 3

if(x>1)
{
                System.out.println("Hello World!");
}
System.out.println("over")
也就是说,如果满足if里面的话
那么Hello World! 就能被执行

如果if控制的语句只有1条
那么{}可以不写
也就是说如果没有{}
那么if控制离他最近的执行语句(如果if条件满足可以执行的话)



第二种
class  IF
{
        public static void main(String[] args)
        {
                int x  = 3;

                if(x>1)
                {
                        System.out.println("Hello World!");
                }
                else
                {
                        System.out.println("fuck");
                }
       
                System.out.println("over");
        }
}

如果if满足,就显示hello world
如果IF不满足,就显示fuck

==============
if else 结构 简写格式: 变量 = (条件表达式)?表达式1: 表达式2:

三元运算符:
好处:可以简化 if else 代码
弊端:因为是一个运算符,所以运算完必须要有一个结果
=========================



第三种
int n = 3

if(n>1)
{
        System.out.println("a");
}
else if (n>2)
{
        System.out.println("b");
}
else if (n>3)
{
        System.out.println("c");
}
else
{
        System.out.println("d");
}

System.out.println("over")


满足任一一条,就结束运算


区分
int n = 3

if(n>1)
{
        System.out.println("a");
}
if (n>2)
{
        System.out.println("b");
}
if (n>3)
{
        System.out.println("c");
}
else
{
        System.out.println("d");
}

System.out.println("over")

有三个独立运行,所以显示的结果为abd
=================================
if 系列的练习

需求,根据用户定义的数值不同。打印对饮的星期英文

答案
int n = 3

if(num==1)
{
        System.out.println("monday");
}
else if (num==2)
{
        System.out.println("tsd");
}
else if (num==3)
{
        System.out.println("w");
}
........
else
{
        System.out.println("nono");
}


=============
需求2:更具指定月份,打印该月份所属的季节
3.4.5春季,6.7.8夏季,9.10.11.秋季,12.1.2冬季

int x = 4;

if(x==3||x==4||x===5)
{
        System.out.println("x+春季");
}
else if (x==6||x==7||x==8)
{
        System.out.println("x+夏季");
}
else if (x==9||x==10||x==11)
{
        System.out.println("x+秋季");
}
else if (x==12||x==1||x==2)
{
        System.out.println("x+东季");
}
else
{
        System.out.println("月份不存在");
}

==========================或者可以写成

if(x>12 || x<1)
{
        System.out.println("x+月份不存在");
}
else if (x>=3 && x<=5)
{
        System.out.println("x+春季");
}
else if (x>=6 && x<=8)
{
        System.out.println("x+夏季");
}
else if (x>=9 && x<=11)
{
        System.out.println("x+秋季");
}
else
{
        System.out.println("冬季”);

======================================
2.6.2
选择结构
switch语句
格式:
switch(表达式)
{
        case 取值1:
        执行语句;
        break;
        case 取值2:
        执行语句
        break;
        ...........
        default:
        执行语句
        break;
}
=========
例

int x = 3

switch(x)
{
        case 4
                System.out.println("a")
                break;
        case 6
                System.out.println("b")
                break;
        case 2
                System.out.println("c")
                break;
        default:
                System.out.println("d")
}

因为int x = 2 所以输出 c

========
z注,
1.被选择的表达式的值,只支持四种类型
byte
short
int
char

2.case 和 default的顺序随意
但是系统只有再读完所有case,并且都不对的情况下才会读default

3.如果default是最后1局那么他的bresk可以不写

4。如果有多个case 的答案一致,那么他们可以写一起
        case 6
        case 7
        case 8
                System.out.println("a")
                break;
===========================
if和switch语句很像
具体什么场景下,应用那个语句呢?
如果判断的具体数值不多,而且符合byte short int char 这四种类型。
虽然2个语句都可以使用,建议使用swtich语句。因为效率稍高

其他情况:对区间判断,对结果为boolean类型判断,使用if,if的使用范围更广

===========================================
第三天
学习根据,毕老师视频03

2.6.3
循环结构
代表语句:whlie, do while ,for
while语句格式:
while(条件表达式)
{
        执行语句;
}
----
do while 语句格式
do
{
        执行语句;
}while(条件表达式)

do while特点是条件无论是否满足,循环体至少被执行一次。

class While
{
        public static void main(String[] args)
        {
                int x = 1;
                while(x<3)
                {
                System.out.println("Hello World!");
                }
        }
}

因为写的是X<3并且 x=1,
所以他会被无限运行

ctrl+c(强制结束命令行运行)

class While
{
        public static void main(String[] args)
        {
                /*
                定义初始化表达式；
                while（条件表达式）
                {
                        循环体（执行语句）；
                }
                */
                int x = 1;
                while(x<3)
                {
                System.out.println("x="+x);
                x++
                }
        }
}
/*切记,while (x<3) 后面不能有分号
=====================
do while 形式

class DO
{
        public static void main(String[] args)
        {
                /*
                定义初始化表达式；
                while（条件表达式）
                {
                        循环体（执行语句）；
                }
                */
                int x = 1;
                do
                {
                System.out.println("x="+x);
                x++;
                }
                while (x<3);
                {
                }
        }
}
/*
while:先判断条件，只有条件满足才执行循环体，
do while：先执行循环体，再判断条件。条件满足，再继续执行循环体
简单一句话：do while ：无论条件是否满足，循环体至少执行一次
*/
----------------
for(初始化表达式;循环条件表达式;循环后的操作表达式)

class FOR
{
        public static void main(String[] args)
        {
                for (int x = 0; x<3 ; x++ )
                {
                        System.out.println("x="+x);
                }               
        }
}
/*
先确定x<3这一步骤，然后执行"X="+X，再试行X++
*/

for与 while 的区别
1.变量有自己的作用域,对于for来讲:如果将用于控制讯黄的增量定义在for语句中,那么该变量只在for语句内有效,for语句执行完毕,该变量在内存中被释放(消失)
2.for和while可以进行互换,如果需要定义循环增量,用for更为合适

总结:
什么时候使用循环结构?
当要对某些语句执行很多次时,就使用循环结构。

class For2
{
        public static void main(String[] args)
        {
                int x = 1;
                for (System.out.println("a"); x<3 ;System.out。println("c") )                {
                        System.out.println("d");
                        x++;
                }
               
        }
}
按照for语言的顺序,显示出来的是adcdc

无限循环的最简单表达式
for(;;)()
或者
while(true)

----
class hao
{
        public static void main(String[] args)
        {
                for (; ; )
                {
                }
               
        }
}
----------
class cha
{
        public static void main(String[] args)
        {
                while (true)
                {
                }
        }
}
=============

练习
/*
1.获取1——10的和，并打印
2,1-100之间7的倍数的个数，并打印
*/
class  While2
{
        public static void main(String[] args)
        {
                //1，定义变量用于存储不断变化的和
                int sum = 0;

                //2，定义变量，记录住不断变化的被加的数
                int x = 1;
                //3,定义循环，重复加法的过程。
                while (x<=10)
                {
                        sum = sum + x;
                        x++;
                }
                System.out.println("sum="+sum);
        }
}
/*
循环注意
一定要明确哪些语句需要参与循环，哪些不需要。
*/
=========================
//用for来体现
class Fort
{
        public static void main(String[] args)
        {
        int sum = 0;
                for (int x = 0; x<=10 ;x++ )
                {
                        sum += x; //a+=b相当于a=a+b,,,,即把a+b的值再赋值给a
                }
                System.out.println("for sum = "+sum);
        }
}
=========================================
/*
1,获取1~10的和，并打印。

*/

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

                /*
       
                //1,定义变量用于存储不断变化的和。
                int sum = 0;

                //2，定义变量，记录住不断变化的被加的数。
                int x = 1;
                //3，定义循环，重复加法的过程。
                while(x<=10)
                {
                        sum = sum + x;
                        x++;

                }
                System.out.println("sum="+sum);

                */
                /*
                循环注意：
                一定要明确哪些语句需要参与循环，哪些不需要。
                */
                /*
          0+1
                1+2
                 3+3
                   6+4
                   */
                //用for来体现。
                int sum = 0;

                for(int x=0; x<=10; x++)
                {
                        sum += x;
                       
                }
                System.out.println("for sum = "+sum);

                /*
                其实这就是累加思想。
                原理：通过变量记录住每次变化的结果。
                通过循环的形式。进行累加动作。

                */
        }
}

=======================================
/*

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


1
12
123
1234
12345



九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9


*/

class  ForForTest
{
        public static void main(String[] args)
        {
                /*
               
                *
                **
                ***
                ****
                *****
               
                不是规律的规律：
                尖朝上，可以改变条件。让条件随着外循环变化。

                尖朝下，可以初始化值，让初始化随着外循环变化。
               
                */

                for (int x=0; x<5 ;x++ )
                {
                        for (int y=0 ; y<=x ; y++ )
                        {
                                System.out.print("*");
                        }
                        System.out.println();
                }

                System.out.println("----------------------");

                /*
               
                1
                12
                123
                1234
                12345

                */

                for (int x=1; x<=5; x++)
                {
                        for (int y=1; y<=x;y++ )
                        {
                                System.out.print(y);
                        }
                        System.out.println();
                }

                System.out.println("----------------------");


                /*
               
                九九乘法表
                1*1=1
                1*2=2 2*2=4
                1*3=3 2*3=6 3*3=9

               
                */

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

        }
}
========================
为了让图形漂亮\t代表制表符,自动对齐

-----------------
2.6.4 其他流程控制语句
break(跳出),continue(继续)
break语句:应用范围:选择结构和循环结构
continue语句:应用于循环结构
注:
a,这两个语句离开英勇范围,存在是没有意义的。
B这个两个语句单独存在下面都不可以有语句,因为执行不到。
C,continue语句是结束本次循环继续下次循环
D,标号的出现,可以让这两个语句作用域指定的范围

错误提示里会说 在switche火loop外部中断  loop代表循环
---

2.7
函数
1函数的定义
2函数的特点
3函数的应用
4函数的重载
--------------------
1什么是函数?
函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称方法。
2函数的格式
修饰符 返回值类型 函数名(阐述类型 形式参数1, 参数类型 形式参数2,.......)
{
                执行语句;
                return 返回值
}
返回值类型:函数运行后的结果的数据类型。
参数类型:是形式参数的数据类型。
形式参数:是一个变量,用于存储调用函数时传递给函数的实际参数。
实际参数:传递给形式参数的具体数值。
return:用于结束函数
返回值:改值会返回给调用者

=============
判断用boolean
比较用int
----

2..4函数的重载(overload)
重载的概念,
在同一个类中,允许存在一个以上同名函数,只要他们的参数个数或者参数类型不同即可。
重载的特点:
与返回值理性无关,只看参数列表。
重载的好处:
方便阅读,优化了程序设计。
重载势力:
//返回两个整数的和
int add(int x,int y){return x+y}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z}
//返回两个小树的和
double add(double x,double y){return x+y}
===========================
2.8.1
概念
同一种类型数据的集合。其实数组就是一个容器。
数组的好处
可以自动给数组中的无数从0开始编号,方便操作这些元素。
格式1:
元素类型[] 数组名=new 元素类型[元素个数或者素组长度]
示例:int[]arr=new int[5];
格式2:
元素类型[] 数组名=new 元素类型{]{元素,元素,....};
int[] arr = new int []{3,5,1,7};
int[] arr = {3,5,1,7};
===
2.8.2内存结构
java程序在运行时,需要在内存中分配空间。为了提高运算效率,有对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
1.栈内存
用于存储局部变量,当数据使用完,所占空间会自动释放。
2,堆内存
数组和对象,通过new建立的实例都存放在堆内存中。
每一个尸体都有内存地址值
是体重的变量都有默认初始化值
实体不在被使用,会在不确定的时间内被垃圾回收器回收

==============================
第四天
学习根据,毕向东视频04
编译只检查语法错误

数组中有一个属性可以直接获取到数组元素个数:length
使用方式:数组名称.length
如System.out.println(arr.length)
就可以告诉你数组的个数
或者可以直接用
比如for(int x=0;x<arr.length;x++)
求数组个数的总和

class Arrayd
{
        public static void main(String[] args)
        {
                int[] arr = {1,2,3,4,5};
                int sum = 0;
                for (int x =0 ;x<arr.length ;x++ )
                {
                        sum += arr[x];
                        System.out.println("sum="+sum);
                }

        }
}
======================
获取数组中的最大值。
        思路：
        1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
        通过一个变量进行临储。
        2，让数组中的每一个元素都和这个变量中的值进行比较。
        如果大于了变量中的值，就用该变量记录较大值。
        3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

        步骤：
        1，定义变量。初始化为数组中任意一个元素即可。
        2，通过循环语句对数组进行遍历。
        3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
       
        需要定义一个功能来完成。以便提高复用性。
        1，明确结果，数组中的最大元素 int。、
        2，未知内容：一个数组。int[]
*/
        public static int getMax(int[] arr)
        {
                int max = arr[0];

                for(int x=1; x<arr.length; x++)
                {
                        if(arr[x]>max)
                                max = arr[x];
                }
                return max;
        }


        /*
        获取最大值的另一种方式。
        可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。


        */
        public static int getMax_2(int[] arr)
        {
                int max = 0;

                for(int x=1; x<arr.length; x++)
                {
                        if(arr[x]>arr[max])
                                max = x;
                }
                return arr[max];
        }


        /*
        获取最小值。
        */
        public static int getMin(int[] arr)
        {
                int min = 0;
                for(int x=1; x<arr.length; x++)
                {
                        if(arr[x]<arr[min])
                                min = x;
                }
                return arr[min];
        }

        //获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。
        /*
        public static double getMax(double[] arr)
        {
               
        }
        */
        public static void main(String[] args)
        {
                int[] arr ={5,1,6,4,2,8,9};

                int max = getMax_2(arr);
                int min = getMin(arr);
                System.out.println("max="+max);
                System.out.println("min="+min);


//                boolean[] ar = new boolean[3];
//                System.out.println(ar[1]);
        }

======================
冒泡排序:相邻的两个元素进行比较,
如果符合条件换位
第一圈:最值出现了最后位。

这么多字，排版下哈大神。弄的我们都不好意思水了

:o当初我第一次接触计算机语言，看的就是毕姥爷的视频，就前4天的东西能让我反复看个1星期才真正搞懂，所以笔记和总结我做的细了点，希望对各位学弟妹们有帮助~~~

这个在这时候插楼是不是不好啊。我做笔记都是做手写的呢，感觉找起来方便，而且印象会深点。但感谢LZ。

阿穆隆 发表于 2014-11-18 23:49
这个在这时候插楼是不是不好啊。我做笔记都是做手写的呢，感觉找起来方便，而且印象会深点。但感谢LZ。 ...

:(反正没人看，我不直播了，桑心ing

朱奕东 发表于 2014-11-18 23:52
反正没人看，我不直播了，桑心ing

额。。。好吧。。。明天再播，挣积分。。。哈哈哈哈哈而且也很好呢啊。你这是已经过去了还是培训完了？

阿穆隆 发表于 2014-11-18 23:57
额。。。好吧。。。明天再播，挣积分。。。哈哈哈哈哈而且也很好呢啊。你这是已经过去了还是培训完了？ ...

看的毕姥爷的视频~~~

朱奕东 发表于 2014-11-19 00:01
看的毕姥爷的视频~~~

那现在还是在学习呢吗？

阿穆隆 发表于 2014-11-19 00:03
那现在还是在学习呢吗？

我在黑马读基础，如果你有不爽的地方欢迎过来打我，我叫孙晓威！~~~

顶一个！

朱奕东 发表于 2014-11-19 00:07
我在黑马读基础，如果你有不爽的地方欢迎过来打我，我叫孙晓威！~~~

:L:L:L年纪大了，不会做那么无聊的事了。。而且你是怎么看出我有不爽的？我看你很爽呢啊。

真是用心

我晕，发这么多

常见问题 如果翻译的时候,计算机提示 javac:找不到文件: 用法:javac< options><source files> -help 用于列出可能的选项，楼主，