该用户从未签到
|
1. java 的方法Method (函数 Function), 功能, 动作/ ^+ G* Q, S0 A7 J* @
1) 方法就是函数: y=f(x)=3x+6;
" L$ \; P: ~3 ?, @! A 2) 方法的语法+ H# B5 T0 Q, g1 w
(修饰词)(返回值类型)(方法名)(参数列表){
! Y9 m8 R9 e( L //方法体7 M, o7 f/ }' h# _8 l
}/ Y% x: P/ C5 L0 \# d/ W9 S
public static void main(String[] args){}
, k2 y h" G& F- b2 I" @- r 如:- N% Q. X# m' L1 M, v0 e/ \
public static int f(int x){+ I# C$ A7 F+ J; `# g! i, o
int y = 3 * x + 4;2 m% e: g" b* d$ B
return y;
: h" O5 B; t3 o+ n) a }
8 v$ L0 Z( g4 b% u- ]7 S& Y( i 4) 如果有返回值定义就必须有return语句, 返回和返回值类型
9 R0 Q0 z+ W+ L3 l- C 兼容的数据/ y K* T6 T/ F! T5 N& y% |+ i
5) 方法的参数和方法内部的变量 都是局部变量,
1 A# Y$ ~. W% V" R, n" h6 @! Z& z) s6 l3 F 这些变量作用域只在方法内部!
4 y1 y& L' p- H 6) 实参: 方法调用时候实际传递的参数变量
" r7 c0 O7 j9 @0 @) ^ 形参: 方法的参数定义,是临时变量.
! G) L( E, t# u( b
$ M* [ r7 w0 v6 T$ h2. Java 运算符
$ O" k/ E, V; E2 s& Y 1) 数学运算符 + - * / %
$ p, C4 L8 e! f! M- a2 T9 w A 运算的封闭性(补码运算的封闭性): " P @' b$ [8 u7 z/ y6 b- w
1.同种类型参与运算(可能需要自动类型转换)
. b: O% f) u9 }5 D+ @! e 2.返回同种类型(可能发生:上溢出和下溢出)- @% z" B# h i
3.byte, short, char 按照int运算4 n" L4 q3 |/ l8 e# }- y3 n1 f/ U
如: int a = 1 + 'A';' o8 H6 y& M0 q6 B
B. 整数的除法是整除- P# t% U- v# `/ c" |8 t
1.除以2相当于移位运算(移动小数点) " G7 ~# O+ k L' L+ }8 m" I; T j% [+ q
C.Java中字面量的运算被Javac优化了, 优化为一个固定的常量., s2 E, e3 Z9 @" D6 s9 R
D. % 计算除法的余数# _0 G5 ]" ?4 O5 H) z) O
1. 0 对其他数的 余数 是04 E; U/ J ]9 E( W4 N" o
2. n%3 是 周期函数, 函数值 [0,3)
' h1 W' t) A/ C. N 3. 负数的余数是负数(考试可能出现, 工作中很少用)5 n6 D+ H- P+ U+ V w j
2 V0 \; ]6 m; o1 j A 2) 自增(自减)运算 ++ --
; K# H4 Y7 [# E/ Z 1. 可以将当前变量自我增加(减少)1
0 t- \6 A2 h! K 2 i++, 后++, 先将i的值作为整个表达的值, 然后将i增加1.
- C5 _* _; ^' u* L; Q# X9 b 3 ++i, 先++, 先将i增加1, 然后将i的值作为整个表达的值.5 \; I# G4 U5 r8 x
int a = i++;/ Q" i. d/ {% E) C0 U7 |
(i++)%3
' N7 w0 D/ |9 i# q2 Q* X9 |: c/ n
3) 逻辑与比较运算 ; L& s2 ^$ ^& d& T3 T: i- g2 ~
1.逻辑运算 与(并且)&& 或(或者)|| 非(否则)! 0 p1 S' E( R0 }( ~5 J1 _4 Y
非短路的逻辑运算 & | , 比较少使用, 逻辑不合理! }. a& N, v4 B
2. 比较运算, 比较变量的值, 就是逐个"位"比较值: > >= < <= == !=
6 z7 j- C* N6 t" `( t 基本类型变量的值就是基本值如: i=13 H) M2 A* Y' X8 R4 t% t: t$ J
引用类型变量的值是对象地址值.(在面向对象阶段详细讲解)
3 |! s1 s" [# p, }* W( n3 f' L% i9 A# V8 k. l7 I _
int i = 1;2 ^3 m+ j* c3 J9 V. z1 A8 @
long l = 1;+ i6 W$ ~% E- v5 ~5 N
System.out.println(i==l); //true
7 D1 e- d2 C. y. U7 v' W8 l: y 4) 条件运算符(3元运算符) * R* h+ g& m) l, _
语法: 条件表达式 ? 表达式1 : 表达式2
+ U7 y, ]/ s4 c( ]& r# m 当"条件表达式"为true时候, 表达式1作为整个表达式的值,
+ c7 J6 D% j7 N) T7 t 否则 表达式2作为整个表达式的值
1 t8 G) Q6 v9 S) E4 w 如: 9 C8 L7 \* ^$ ]1 [! O( l
boolean isBoy = true;
5 w7 L$ I+ i* @* l! R6 J int level = isBoy ? 2 : 3 ;// 2
' g4 w, R: i* |+ ]4 H8 ?
% `7 ~% w' _3 }. C3. 分支流程控制
; J4 i2 b6 u+ w3 z: g' U, m 1) if ... else, _& `% i' U9 X+ E# A' x# P
语法: if(布尔表达式){
$ F# X9 j, p' k) b+ g$ G8 N //语句块..& @- x8 P/ }( ?8 K* N
}else{
* T" g0 { n0 n7 {: ?! t4 ^ //语句块
. l' ~9 a1 s; D }
7 T9 w! x' A9 @ 嵌套: if(布尔表达式){
6 Q0 l" ]# i- t) Z# L9 I$ s //...8 ]$ U4 i; d1 W1 |* A R; }: J. _3 r
}else if(布尔表达式){' _ o+ G, r) D& ?, u4 J
//...! W! D( U% `5 Q, _
}else if(布尔表达式){
5 K- k: X" x p( b //.... i+ S) P5 Q: ~: l
}else{# ^" f8 D. z% O7 N' x6 R
//...
' P; r6 L @* q. ~! E& V) h }! \0 B9 a7 s: G+ V7 ^5 |
5 _ j: g" T. I- v
2) switch ... case1 _) i; x6 r* _6 q5 Y# r. `8 F" k# H
语法: switch: 开关, case: 情况下7 J0 P' k( M9 C0 z2 }. Y+ Q, ~
switch(整数表达式){ , u* a/ n* ~: O/ a5 t
case 整数常量1:
0 B8 r- k% T1 F/ a& d4 Y //语句序列
- M" V* v2 g, Q! ^- r% b! [ break;
; `% W) J- W1 I+ E+ o case 整数常量2:
4 ^' g( k4 [% K6 m' v) m& [ //语句序列
$ f! ]/ c: e3 a* p3 q3 y break;
/ M6 Q( b1 f# p default:
) U7 v2 }0 J5 |9 \3 D //语句序列. u: L$ m1 g* J
}
7 t/ o+ t% x {% r7 V$ | A. switch条件: 只能是整数(int byte char short)表达式0 ]8 s2 r: O; k! L% @
switch 不能处理long 或其他类型' E, j _6 h0 W
B. case 只能是整数(int byte char short)常量, 不能使用8 C& ]: ?8 c: e
变量及表达式. 如: '中'* a3 k) f* |! t) H; l" @
C. break 跳转到switch结束继续执行, 可以根据业务逻辑是否使用
8 o8 Q7 Z) f+ C" a% ~( P# L 经常都写break
* Y3 c* \+ Q U# ^6 Y! E7 x N4 ]
$ X' e* O, k0 P# p4 Y4. 循环控制
( U* G' {, {, B4 q2 _ 1) While 循环控制
/ o L/ x" G9 D9 ` 语法:
9 b9 e v5 M$ u while(布尔表达式){
5 N* G: N* W1 s+ Q9 u //循环体 语句序列. g" H! x2 m( o" j, C) ?) u6 E
}
. v1 }5 Z8 D- L( Y# |( y; h; j. h( F
- I/ L4 }. S8 Z1 N) N |
|