注释
1.单行注释
//
2.多行注释
/*
*/
3.*文档注释
关键字
被JAVA赋予特殊含义的单词。特点：
1.都是小写字母
2.有特殊颜色
保留字
GOTO CONST
常量：// 在运行阶段 不会发生变化
1.字符串常量
System.out.println("helloworld");//两个双引号之间的部分 System.out.println("黑马程序员");
2.整数常量
System.out.println(666); System.out.println(-28);
3.小数常量
4.字符常量
System.out.println('A');//单引号内有且仅有一个字符 可以为空
5.布尔常量 true false
6.空常量 null
Java数据类型
基本数据类型
四类八型
整数类 :byte (1) short(2) int(4) long(8)
//byte(-128-127) int 21亿
浮点数 ：float(4) double(8)
布尔 （1）
字符 0-65535
//long类型 8421码 float ieee码
变量：定义不能重载(加H,L)
标识符
大驼峰（第一个大写）（类的命名），小驼峰（首字母小写）newWorld（变量，方法名）
数据类型转换
1.自动转换
int+byte=int
byte、short、char 运算时直接提升为 int
2.强制转换
问题：
1.数据丢失
2.数据溢出
ASCII编码
0：48
9：57
A: 65
Z: 90
a: 97
z: 122
运算符
算术：+ - * / % ++ --
int a = 1; int b = ++a;
i++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。
int a = 1; int b = a++;
++i: 变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b 的结果是1。
赋值：= ， += ， -=，*=，/=，%=
比较：==，>= , <= , != , > , <
逻辑：&&（短路与左边False，右边不管） ， || (短路或左边Ture,右边就不管)，%,|
字符串相加
1. 前加
20+100+“字符串”=120“字符串”
2. 后加
“字符串”+20+100 = “字符串“20120
数据输入
1.导包
import java.util.scanner;//在定义类前 （public class xxx）
2.创建对象
Scanner sc = new Scanner(System.in);
3.接受数据
Int xxx = sc.nextInt(); byte xxx = sc.nextbyte(); String xxx = sc.nextline();
switch
/System.out.println() = sout;
/public static void main (String[] args){} 快捷键psvm；
格式：
switch(表达式){
case1:语句体1;
break;
case2:语句体2;
break;
...
default:语句体n+1;
break//break可以忽略;}
case穿透
switch（表达式）{
case3:
case4:
case5：System.out.ptintln("春季")；break;
case6:
case7:
case8:System.out.ptintln("夏季")；break;
default:break;
}
注意：表达式的值能用哪些：byte short int char String 枚举 /从当前匹配的数据开始执行，知道遇到下一个break;/
CASE可乱序，但是从上到下进行匹配，直到遇到Break;
if...else与Switch主要区别:
1.if...else的功能大于SWITCH
2.if...else的比较过程比较繁琐 SWITCH底层会创建一个跳表直接匹配 效率高，弊端：创建跳表需要消耗时间和空间。
循环结构
组成部分：
①初始化语句 //只执行一次
②条件判断语句 //返回值为true才能进行
③循环体语句
④条件控制语句
for语句 ：
for(初始化语句;条件判断语句;条件控制语句){
循环体语句；
}
//5.for(x.for )idea的快捷键
//math.pow(ge,3) 立方
while语句：
基本格式：
//①初始化语句；
wihle(②条件判断){
③循环体；
}
for 与While 的使用：
明确循环次数For,不明确范围用While.
for与WHILE的条件控制的作用域不同
死循环：
for(;;){}
while(true){}
do...while:
①初始化语句；
do{③循环体；
④条件控制语句；
}while（②条件判断；）
//第一次执行无需判断
循环跳转语句：
continue:跳过本次循环，进入下次循环
break:直接结束整个For/while 循环
九九乘法表
for(inti=1;i<=9;i++){//行
for(intj=1;j<=i;j++){//列
System.out.print(i+"X"+j+"="+(i*j)+"\t");
}
System.out.println();//Line换行=print("n")
}
制表符"\t"
随机数Random
用法： //类比Scanner
1.导包 1.导包
import java.util.Random; import java.util.S
2.创建对象
Random r = new Random;
3.调用方法
int num = r.nextInt(bound:x);//0-x i<x
随机验证码
Randomnum=newRandom();
for(inti=0;i<5;i++){
intx=num.nextInt(26)+97;
System.out.print((char)x+"\t");
}//5个小写验证码
Scannercs=newScanner(System.in);
Randomr=newRandom();
intnum=r.nextInt(100)+1;
System.out.println("请输入要猜的数字");
intguessnum=cs.nextInt();
while(guessnum!=num){
if(guessnum>num){
System.out.println("大了");
}elseif(guessnum<num){
System.out.println("小了");
}
guessnum=cs.nextInt();
if(guessnum==num){
System.out.println("猜对了");
}
//猜数字
方法（函数：代码块）
定义：
public static void 方法名(){ //public static void method(){}
//方法体：代码块}
调用：
方法名（）； // method();
带参数的方法定义和调用
public static void 方法名（参数1）{
方法体；}
public static void 方法名（参数1,参数2，参数3）{
方法体；}
//范例： public static void getMax(int num1,int num2){
...}
带返回值的定义和调用
public static boolean isEvenNumber(int number){
return true;}
public static int get max(int number){
return 100;}
//方法不能嵌套定义
//void 类型可以省略return; 也可以单独加return;后面不加数据类型
通用类型
public static 返回值类型 方法名(参数) {
方法体;
return 数据 ;
}
方法重载//函数重载，形参不一样，函数名一样，顺序不一样；
方法的参数传递
基本数据类型的参数，形式参数的改变，不影响实际参数
形参是地址（数组名）会改变
//引用值
publicstaticvoidmain(String[]args){
int[]arr={10,20,30};
System.out.println("调用change方法前："+arr[1]);//调用change方法前：100
change(arr);
System.out.println("调用change方法后："+arr[1]);//调用change方法后：200
}
publicstaticvoidchange(int[]arr){
arr[1]=200;
}
//基本参数
publicstaticvoidmain(String[]args){
intnumber=100;
System.out.println("调用change方法前："+number);
number=change(number);
System.out.println("调用change方法后："+number);
}
publicstaticintchange(intnumber){
number=200;
returnnumber;
}
类和对象
类：
类是对象的数据类型
lei是具有相同属性和行为的一组对象的集合
类{
成员{属性}；
方法；
}
属性：
对象具有的各种特征，每个对象的每个属性都具有特定的值
行为：
对象能执行的操作。
类使用样例：
classStudent{
//成员变量
Stringname;
intage;
//成员方法
publicvoidstudy(){
System.out.println("好好学习，天天向上");
}
publicvoiddoHomework(){
System.out.println("键盘敲烂，月薪过万");
}
}
学生测试类
*/
publicclassStudentDemo{
publicstaticvoidmain(String[]args){
//创建对象
Students=newStudent();
//使用对象
System.out.println(s.name+","+s.age);
s.name="林青霞";
s.age=30;
System.out.println(s.name+","+s.age);
s.study();
s.doHomework();
}
}
成员变量和局部变量
类中位置不同：成员变量在类中方法外，局部变量在方法内；
内存位置不同：成员变量（堆内存），局部变量（栈内存） //见数组
生命周期不同：成员变量：与对象伴生 ；局部变量：随方法的调用而诞生，调用完消失
初始化值不同：成员变量：有默认初始化值；局部变量没有默认初始化值，先定义赋值再使用
封装
private 关键字
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作。
1.提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
2.提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
this 关键字
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
构造方法
结构:
public class 类名{
修饰符 类名( 参数 ) {
}
}
构造方法和类名一致，可重载
标准类制作
classStudent{
//成员变量
privateStringname;
privateintage;
//构造方法
publicStudent(){
}
publicStudent(Stringname,intage){
this.name=name;
this.age=age;
}
//成员方法
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetName(){
returnname;
}
publicvoidsetAge(intage){
this.age=age;
}
publicintgetAge(){
returnage;
}
publicvoidshow(){
System.out.println(name+","+age);
}
}
/*
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/
publicclassStudentDemo{
publicstaticvoidmain(String[]args){
//无参构造方法创建对象后使用setXxx()赋值
Students1=newStudent();
s1.setName("林青霞");
s1.setAge(30);
s1.show();
//使用带参构造方法直接创建带有属性值的对象
Students2=newStudent("林青霞",30);
s2.show();
}
} |
|
收藏
淘帖
踩
