|
该用户从未签到
|
1. java 的方法Method (函数 Function), 功能, 动作
2 m3 s" Z$ V7 V* j" G: h 1) 方法就是函数: y=f(x)=3x+6;
/ P% @# W. L* ?- I0 }7 T. A$ g 2) 方法的语法
/ U- Z# m( ]+ i* u5 D (修饰词)(返回值类型)(方法名)(参数列表){
/ z0 K' f( F- w. ? |2 L5 S; A //方法体4 |# Y7 v# j7 g( Z( L4 O0 w7 r
}: K% w. b+ F) Z; Z
public static void main(String[] args){}
. u' t0 z' E& V; j+ i) b# x& b7 R 如:4 h8 O* ?3 W B! F7 U
public static int f(int x){
9 W, ]" J2 ^/ } r) b, ~! h int y = 3 * x + 4;; U& ~" [) T# Y9 _2 p: `
return y; X: [/ H, Y& e
}
8 }3 _* P5 i, a5 H5 X 4) 如果有返回值定义就必须有return语句, 返回和返回值类型. h) a9 L1 k+ x( A6 l
兼容的数据
8 s1 U! X+ a8 Y9 t5 Y d 5) 方法的参数和方法内部的变量 都是局部变量,
4 S, n8 l; p% R% K7 M 这些变量作用域只在方法内部!
7 i4 `5 _( Q7 _5 V$ q( T 6) 实参: 方法调用时候实际传递的参数变量
, r9 M! B$ P& l 形参: 方法的参数定义,是临时变量.
4 P8 d) d, }' r! Z$ `% U; g* n7 l
2. Java 运算符
3 m( Q$ \) V, c) c) @ 1) 数学运算符 + - * / %
: g1 `% M! l' L4 Q1 j/ T$ `; A3 a A 运算的封闭性(补码运算的封闭性): 1 F# q9 g9 \; T
1.同种类型参与运算(可能需要自动类型转换)
8 H- i: Q3 Q! S' T6 ]6 E' ` 2.返回同种类型(可能发生:上溢出和下溢出)% G5 V& G8 H2 M- V; y
3.byte, short, char 按照int运算3 k1 D4 S9 H4 h J! L
如: int a = 1 + 'A';
! X7 y& ]7 E) U+ p! H# b' n B. 整数的除法是整除
2 K* E& r, B" T 1.除以2相当于移位运算(移动小数点)
D# @8 }1 r; r0 g) D4 G: f0 } C.Java中字面量的运算被Javac优化了, 优化为一个固定的常量.
8 d# W4 O' |* K3 w! D2 u D. % 计算除法的余数
2 A" s! L F9 a1 y1 z 1. 0 对其他数的 余数 是0
/ o9 ~. k& g) O2 ^6 @, R4 G6 R( o! A 2. n%3 是 周期函数, 函数值 [0,3)3 ]3 A# b2 q" L! @6 B. @. c9 l4 k
3. 负数的余数是负数(考试可能出现, 工作中很少用)
0 U, R8 G4 P2 D3 t& a8 E, u% Y* v& z' ~% E% u0 N! o
2) 自增(自减)运算 ++ --5 q" O- u- j, P: ?
1. 可以将当前变量自我增加(减少)1
% [6 Q( i1 D% Y3 n, ] 2 i++, 后++, 先将i的值作为整个表达的值, 然后将i增加1.' f. E1 D+ {) O: K& Y1 o$ l- C t
3 ++i, 先++, 先将i增加1, 然后将i的值作为整个表达的值.! R# J0 C" v) q+ k q; i: T
int a = i++;9 i) ?7 O' D; r' E0 e
(i++)%3: ?8 s k1 r' y( j! } \7 y: ~
: [- R6 W! U$ z0 a 3) 逻辑与比较运算
9 ~* h1 D8 z) t5 c4 E 1.逻辑运算 与(并且)&& 或(或者)|| 非(否则)!
0 z. `4 j2 g$ `# \: ?7 s 非短路的逻辑运算 & | , 比较少使用, 逻辑不合理. s1 i, B3 y: @7 p0 h' S
2. 比较运算, 比较变量的值, 就是逐个"位"比较值: > >= < <= == !=
- F; i# s/ ]" P( c 基本类型变量的值就是基本值如: i=1
E2 F$ E! K0 C 引用类型变量的值是对象地址值.(在面向对象阶段详细讲解) d5 v3 w- [$ U! e) d: W( p: Q
N. l% ~( M3 }6 j, T* W; i! F
int i = 1;
2 V# A- a% q' U# W9 t long l = 1;. ^1 L* S# i. Z$ P9 ~' l# k2 L A
System.out.println(i==l); //true
: h4 n, h. u$ C9 r( R" k8 o6 @7 v 4) 条件运算符(3元运算符) ! l$ h8 o& u- \. A2 Z+ Y. u% D' [
语法: 条件表达式 ? 表达式1 : 表达式2, M6 B/ Y. _) D5 r2 T7 P
当"条件表达式"为true时候, 表达式1作为整个表达式的值, 7 K( k# A: Z" h+ ^) Q9 {, {
否则 表达式2作为整个表达式的值
9 p r6 F3 ?- n* p6 N; b 如: $ k5 F! m2 H+ y' f8 P& Z8 c
boolean isBoy = true;) ` ^9 ?* D, v0 x
int level = isBoy ? 2 : 3 ;// 2
% w* v" F4 B6 b: b$ H! q1 G
: n" Y. J5 b5 @3. 分支流程控制
# A+ w2 S% F+ O( e3 q 1) if ... else$ P& T5 t7 C( G& n
语法: if(布尔表达式){5 M& o# n* N- m }* H* @, q
//语句块..2 e/ G; l) f$ J4 L; c0 E- B
}else{
/ d6 m% L9 N* { //语句块
( o; l$ {. j! D$ v2 G }4 e! }- p: H# [6 D( Z) e. `
嵌套: if(布尔表达式){: u2 L& |3 k+ _! k
//...
! W& G1 K9 i/ g" e( \8 ` }else if(布尔表达式){
: X6 e M( T8 f //...
% K( e9 x6 K5 i- g }else if(布尔表达式){
3 y$ P% r% ?+ V4 F. T- q //...1 |% m) L$ @3 ~' ~0 ?
}else{+ {; G5 l2 e( ]" U4 d3 \
//...
3 c- m* G2 }. A }
8 a# r* E+ [# N+ J& _0 d8 I: v' S& s' k& W/ O1 P1 R) h. F- \
2) switch ... case+ ?( r+ @2 `. y/ C) m% K/ @
语法: switch: 开关, case: 情况下
+ M6 H; }: u2 J& t switch(整数表达式){
w1 J. X. `1 g, R8 [7 q4 d- w0 b case 整数常量1:
. o i4 H) ^* d( q1 C# X4 @0 @ //语句序列0 a+ m0 i7 m8 K/ G. S' K
break;( w1 d8 a; H+ d( P' K/ I3 t
case 整数常量2:
& R; @7 y r& N2 H. q5 k //语句序列$ Y4 ]" b5 Z3 T; f: u
break;
$ Z; C9 O% V3 X: V default:
: }# J( b) @; D3 m& o+ i3 O# V; A //语句序列
0 C% |4 J% K+ n! W }
" G) f3 N% F1 b A. switch条件: 只能是整数(int byte char short)表达式
0 B& U* I D0 l* o" ` switch 不能处理long 或其他类型
0 q1 |. k N! k B. case 只能是整数(int byte char short)常量, 不能使用
+ c. D, u! T# Q 变量及表达式. 如: '中'
; v) A2 K' Q0 M; M, K6 b C. break 跳转到switch结束继续执行, 可以根据业务逻辑是否使用" Q, r. B9 V% N2 I- v
经常都写break8 Z% L& E! [' [* j
2 a0 [% N; i3 c0 `; ?+ A+ d& J
4. 循环控制
) ~2 M0 {- F) ^ k& E 1) While 循环控制
+ Y/ }! T. K% W$ x4 t) V 语法:
/ @& Y6 `$ m" y7 k; ~1 U while(布尔表达式){
$ x4 V3 R0 H' P1 j% C' O/ R# n //循环体 语句序列4 s* u! g$ [ a3 {% G3 j0 c' h6 I1 @
}
, {: f" X6 V& e4 z0 i& v/ m1 |
4 q) r( c8 y0 |
; F: L! P8 P0 s |
|