|
该用户从未签到
|
1. java 的方法Method (函数 Function), 功能, 动作' e4 F7 t* u6 j9 S- {+ ]' C# a
1) 方法就是函数: y=f(x)=3x+6;
4 Y; v' O5 a9 V8 q 2) 方法的语法
& F; |3 r; M5 V/ F! V (修饰词)(返回值类型)(方法名)(参数列表){! F3 l& A D0 y5 m8 R
//方法体+ Z- r. ^$ C5 Q9 g; ?3 P
}: q, T# @% @, T& {
public static void main(String[] args){}
7 o+ E' I* K9 C0 n" F* ?/ r 如:
) [4 |) L, C# k2 t/ v public static int f(int x){
" a4 L/ ` l4 ]1 |8 [ int y = 3 * x + 4;
2 P& P( O, c# `$ A return y;( \- f+ @2 v" ~
}
9 ~* `0 V( g3 H9 g" O1 V4 [! f+ C 4) 如果有返回值定义就必须有return语句, 返回和返回值类型
+ G: n* T( N4 t) E. H( O7 k 兼容的数据
$ a7 C! V- q+ c) v' @9 Q9 E1 t 5) 方法的参数和方法内部的变量 都是局部变量,# N# g, R) z0 D, B3 a- b, ^
这些变量作用域只在方法内部!
0 s9 q6 A' h* O) Y 6) 实参: 方法调用时候实际传递的参数变量3 C r7 O9 Y p9 {
形参: 方法的参数定义,是临时变量.
6 o' s2 z' c; a% G; ]
# u& I) ^, J/ @ c& V6 }2. Java 运算符
+ o s) W9 z) v4 T* s; O$ E5 E 1) 数学运算符 + - * / %
* c. f2 d- J4 R" o8 g A 运算的封闭性(补码运算的封闭性):
8 F4 Z% R H' n3 \* @ Q1 n, w0 [ 1.同种类型参与运算(可能需要自动类型转换)
9 M" c I6 _! r9 V% Y, W& o4 E- y 2.返回同种类型(可能发生:上溢出和下溢出)
! }2 k& E( N3 T1 x. m 3.byte, short, char 按照int运算: F5 G4 w3 `. S5 x
如: int a = 1 + 'A';- m3 T7 G( i1 @8 N* {& b* w
B. 整数的除法是整除/ Z" z _1 A, B `* ^
1.除以2相当于移位运算(移动小数点)
* g& v0 i% ]: H) y$ A& U5 q C.Java中字面量的运算被Javac优化了, 优化为一个固定的常量.' _" D7 c6 i. o4 P/ @% a
D. % 计算除法的余数9 U" R/ r5 z& v1 c b
1. 0 对其他数的 余数 是0
( `; X6 t& m: L$ @4 H1 m, [ 2. n%3 是 周期函数, 函数值 [0,3)
G7 z( Z4 y' ?$ C! W% j; X 3. 负数的余数是负数(考试可能出现, 工作中很少用)' l2 v2 r! l! l# _8 U+ @
* S5 n* P' M2 T/ U- h
2) 自增(自减)运算 ++ --
/ c% p+ L, \' J5 l# C+ L5 P2 d; H: } 1. 可以将当前变量自我增加(减少)1
, r3 Y$ D' t) X8 S' l 2 i++, 后++, 先将i的值作为整个表达的值, 然后将i增加1.3 ^7 c4 T. j, H) P
3 ++i, 先++, 先将i增加1, 然后将i的值作为整个表达的值.
7 W7 g- \( N d) Q2 f int a = i++;
: F4 V4 o. V& L, j (i++)%3
1 D) g1 D: n) b* N; _ F1 o6 T2 u! b& \9 O( f, j. T
3) 逻辑与比较运算
' Y" g- |8 @/ F" {( h3 Z# } 1.逻辑运算 与(并且)&& 或(或者)|| 非(否则)! " u' c9 h# R' A
非短路的逻辑运算 & | , 比较少使用, 逻辑不合理
P1 W3 ]1 ~0 x* |' H0 L! C1 F 2. 比较运算, 比较变量的值, 就是逐个"位"比较值: > >= < <= == !=: F$ _4 z. Y& P8 b- I# j- m s
基本类型变量的值就是基本值如: i=17 e) p; |, z p: D. l, H1 V+ z
引用类型变量的值是对象地址值.(在面向对象阶段详细讲解)( @& s1 T. Y1 I3 N4 s' D) Z2 ^
w7 I7 y& {; A g) T& K int i = 1;+ u( `' K' L( h; `8 d6 K
long l = 1;$ P# h q7 K3 f0 J
System.out.println(i==l); //true4 d( n3 C* Z' }
4) 条件运算符(3元运算符) ; I0 s/ D: G0 ]1 u4 m: P' j4 i
语法: 条件表达式 ? 表达式1 : 表达式2% R. T) Y0 z. I/ ], X
当"条件表达式"为true时候, 表达式1作为整个表达式的值,
$ A$ W5 D& B3 L+ @ 否则 表达式2作为整个表达式的值3 a* Q" G4 i6 s% ]2 U4 n3 v8 ~
如:
# D: V) a2 M. Q2 ^% b boolean isBoy = true; a1 `/ u; {5 n b
int level = isBoy ? 2 : 3 ;// 2
# q/ R# @4 [" F N
, {5 I6 Y; z" e5 P3. 分支流程控制
$ J" Z8 L: t; i( Q8 Y2 m Z 1) if ... else+ m$ _& W8 M: D( ?* A
语法: if(布尔表达式){, L7 N! ^' K# }% @! Y" X S
//语句块.., I5 k6 G: Z/ E1 Y4 ^
}else{
& K' B% C, P0 w& B2 t //语句块
& [/ v% F( ~0 {' Y+ E$ o8 O; @ }
* X; l& d6 ~( O, {0 m' W9 N8 F3 | 嵌套: if(布尔表达式){
5 N& c4 g: Z6 _! t, p# t2 p //...2 W0 h2 K. L, ?$ Q
}else if(布尔表达式){
# i. r3 j/ K9 m# c: W& k; ?* x+ | //...
8 M c k% p6 E& O# q0 q }else if(布尔表达式){( q% @7 X. b0 N, T0 Q
//...' W1 R o* l/ l( n; ]: m
}else{
" W# d& O# A8 S' e //...* I0 r1 h& j4 }( t& H, C8 ~
}
; o- ], G+ e/ g# l; w, G \: j. r4 E) C7 w
2) switch ... case
3 D) t+ `5 g8 P ]* f 语法: switch: 开关, case: 情况下
. C# ^- t/ u* q7 ^ switch(整数表达式){
: g* x( A4 {( a, d- b# q8 n case 整数常量1:9 a" a8 X* m0 ~
//语句序列
' d: D' ^( ^# v X7 y/ g4 w break;
1 F6 u7 s' H2 v6 x case 整数常量2:: C O7 I2 {) K2 O% G+ {
//语句序列
& ?; P& Q' |% R; F& {. k& z break;1 f- l/ V) a9 l4 I6 Q0 p, ^& t
default: ! }$ n, K4 l/ u" S% Q
//语句序列
; f7 j# j: a& K& w/ o/ e1 u; P" n }
$ A6 h! F' G& r& f( ]1 X A. switch条件: 只能是整数(int byte char short)表达式1 Z6 O2 i0 K7 [' p( K
switch 不能处理long 或其他类型: t$ _" c' J" F- V& L# |6 g, @
B. case 只能是整数(int byte char short)常量, 不能使用
: }( l& j6 }- t) M 变量及表达式. 如: '中'' m3 z; y# O* G; l& C* s
C. break 跳转到switch结束继续执行, 可以根据业务逻辑是否使用+ [) f) n- B O6 [. b
经常都写break, F9 o w' \9 J; f& {' P
" B: h+ I" ^" y+ {
4. 循环控制
6 M% h- q6 `( p! K 1) While 循环控制
* q% `8 {' `- `3 d' @# Z: x 语法:6 D' t) |; |' t$ k. i; v& ]% t
while(布尔表达式){
& M6 @ Y& z3 j1 ` {# _1 C //循环体 语句序列( I1 Y' [' E! G& s. b
}
: N; v+ m: X9 b/ V' ~6 B! n2 X7 m& V. j- \) l
" M0 f2 \, s' N6 @7 h) n
|
|