注释
在程序上方添加说明信息
1.单行注释//
2.多行注释/*内容*/
3.文档注释/*内容*/
关键字
关键字特点:
关键字的字母全部小写
常用的代码编辑器,针对关键字有特殊的颜色标记
class
用于(创建/定义)一个类,后面跟随类名
字面量
数据在程序中的书写格式
字符串
public class ValueDemo1{public static void main(String[] args){//整数System.out.println(666);//小数System.out.println(1.93);//字符串System.out.println("黑马程序猿");System.out.println("尼古拉斯赵四");//字符System.out.println('男');syutem.out.println('女');//布尔System.out.println(true);System.out.println(false);//空syutem.out.println("null")}
}
特殊字面量
\t:在打印时,把前面字符串长度补齐到8,或者8的整倍数,最少补一个空格,最多补8个空格
变量
在程序的执行过程中,其值有可能发生改变的量(数据)
格式:
数据类型 变量名 = 数据值;
public class VariableDemo{//主入口public static void main(String[] args){//定义变量int a = 10;System.out.println(a);}
}
变量使用方法
1.基本用法
定义变量,再进行输出
2.变量参与计算
int b = 30;
int c = 20;
System.out.println(b + c);
3.修改变量记录的值
注意事项:
1.在一条语句中,可以定义多个变量
int d = 100, e = 200, f = 300;
2.变量在使用之前必须赋值
运算符
ps:在代码中如果有小数参与计算,结果有可能不精确
整数计算只能等得到整数
数值拆分
公式总结:
个位:数值%10
十位:数值/10%10
百位:数值/100%10
算数运算符
"+"操作的三种情况:
1.数字相加
2.字符串相加
3.字符相加
类型转化的分类:
隐式转换:
取值范围小的数值->取值范围大的数值
byte short char三种类型的数据在运算时,都会先升级为int,然后再进行运算
强制转换:
取值范围大的数值->取值范围小的数值
格式:目标数据类型 变量名 =(目标数据类型)被强转的数据
原码.反码.补码
原码:十进制数据的二进制表现形式,最左边是符号位,0为正,1为负
反码:为了解决原码不能计算负数的问题而出现
判断和循环
defualt的位置和省略:
1.位置:default不一定写在最下面,我们可以写在任意位置
2.省略:default可以省略,语法不会有问题,一般不建议省略
case穿透:
因为语句中没有break,语句没有结束,所有语句都执行了
使用场景:如果发现多个case的语句体重复了,那么可以使用case穿透去简化代码
Switch新特性
package com.itheima.demo11;
//switch新特性
public class switchstyle {public static void main(String[] args) {int number = 10;switch (number){case 1 -> {System.out.println("一");}case 2 -> {System.out.println("二");}case 3 -> {System.out.println("三");}default -> {System.out.println("没有这种选项");}}}
}
for循环
扩展小点:
1.求和的变量不能定义在循环里面,因为变量只在所属大括号中有效
2.如果我们把变量定义在循环里面,那么当前变量只在本次循环中有效
当本次循环结束之后,变量就会从内存中消失.
第二次循环开始时又会重新定义一个变量
高级循环
无限循环:循环一直停不下来
一般使用while循环
for(;;){System.out.println("学习")
}
while(true){System.out.println("学习")
}
do{System.out.println("学习")
}while(true)
跳转控制语句
在循环的过程中,跳到其他语句上执行
continue:跳过本次循环,继续执行下次循环.
break:结束整个循环
数组
概念:数组指的是一种容器,可以用来存储同种数据类型的多个值
数组容器在存储数据的时候,需要结合隐式转换考虑
建议:容器的类型,和存储的数据类型保持一致
数组的定义
格式一:
数据类型[] 数组名
范例:int [] array
格式二:数据类型 数组名[]
范例:int array[]
数组初始化
1.静态初始化
完整格式:数据类型[]数组名 = new 数据类型[]{元素1,元素2,元素3…}
2.动态初始化
概念:初始化时只指定数组长度,由系统为数组跟配初始值
格式:数据类型[]数组名 = new 数据类型[数组长度]
数组默认初始化值的规律
整数类型:默认初始化值为0
小数类型:默认初始化值为0.0
字符类型:默认初始化值/u0000
布尔类型:默认初始化值false
引用数据类型:默认初始化值 null
数组元素访问
获取数组里面元素
package com.itheima.demo11;public class Arraydemo2 {public static void main(String[] args) {//利用索引对数组中元素进行访问//1.获取数组里面的元素//格式:数组名[索引]int[] arr = {1,2,3,4,5};//获取数组中第一个元素//其实就是0索引对应的元素int number = arr[0];System.out.println(number);//获取数组中1索引上对应的数据,并直接打印出来System.out.println(arr[1]);}
}
数组的遍历
将数组中所有内容取出来,取出来之后可以(打印,求和,判断…)
方法的注意事项
1.方法不调用就不执行
2.方法与方法之间是平级关系,不能相互嵌套定义
3.方法的编写顺序与执行顺序无关
4.方法的返回值类型为void,表示该方法没有返回值
没有返回值的方法可以省略return语句不写
如果要编写return,后面不跟具体数据 .
5.return语句下面,不能编写代码,因为永远执行不到,属于无效代码
方法的重载
同一个类中,方法名相同,参数不同的方法.与返回值无关.
设计对象并使用
类和对象
类：是共同特征的描述（设计图）；对象：真实存在的具体示例
对象：public class 类名 { 1.成员变量（代表属性，一般为名词） 2.成员方法（代表行为的，一般为动词） }
定义类
1.类名首字母建议大写,英文,有意义,满足驼峰式,不能用关键字,满足标志符规定
2.一个代码文件中可以定义多个类但只能一个类是public修饰的,public修饰的类名必须是java代码的文件名称
成员变量的格式
1.成员变量完整定义格式:修饰符 数据类型 变量名称 = 初始化值
2.一般无需指定初始化值
封装
对象代表什么,就得封装对应数据,并提供数据对应行为
private关键字
1.是一个权限修饰符
2.可以修饰成员(成员变量和成员方法)
3.被private修饰的成员只能在本类中才能访问
构造方法格式
特点:
构造方法注意事项
1.构造方法的定义:
如果没有定义构造方法,系统将给出一个默认的无参数构造方法
如果定义了构造方法,系统将不在提供默认的构造方法
2.构造方法的重载
带参构造方法,和无参构造方法,两者方法名相同,但是参数不同,这叫构造方法的重载
3.推荐使用方法:
无论是否使用,都手动书写无参数构造方法,和带全部参数构造方法
标准的javabean类
1.类名需要见名知意
2.成员变量使用private修饰
3.提供至少两个构造方法
无参构造方法
带全部参数构造方法
4.成员方法
提供每一个成员变量对应的setXXX()/getXXX()
如果还有其他行为也要写上
键盘录入
1.第一套体系
nextInt();接受整数
nextdouble();接收小数
next();接收字符串
遇到空格,制表符,回车就停止接收,这些符号后面就不接受了
2.第二套体系
nextLine();接收字符串
可以接收空格,制表符,回车就停止接收数据
Ps:两套体系不能混用
内存图
1、加载class文件
2、申明局部变量
3、在堆内存中开辟一个空间
4、默认初始化
5、显示初始化
6、构造方法初始化
7、将堆内存中的地址赋值给左边的局部变量
等号的直接赋值是赋值上地址，并将被赋值与地址之间建立联系，而赋值与地址之间的联系断开，赋值的那个变成空
基本数据类型和引用数据类型
1.基本数据类型：数据值是存储在自己的空间中
特点：赋值给其他变量，也是赋的真实的值。
int a=10;
int b=a;引用数据类型：数据值是存储在其他空间中，自己空间中存储的是地址值
2.特点：赋值给其他变量，赋的地址值
Student s1=new Student();
Student s2=new Student();
s1.num=10;
s2.num=s1;this的内存原理
public class Student{private int age;public void method(){int age=10;System.out.printIn(age);System.out.printIn(this.age);}
}this的作用：区分局部变量和成员变量
this的本质：所在方法调用者的地址值
成员变量和局部变量
成员变量：类中方法外的变量
局部变量：方法中的变量
小练习
//GrilFriend.java
public class GirlFriend {String name;int age;String gender;public void sleep(){System.out.println("女朋友正在睡觉");}public void eat(){System.out.println("女朋友正在吃饭");}
}//GrilFriendTest.java
public class GirlFriendTest {public static void main(String[] args){GirlFriend gf1=new GirlFriend();gf1.name="小凡凡";gf1.age=19;gf1.gender="女";System.out.println(gf1.name);System.out.println(gf1.age);System.out.println(gf1.gender);gf1.sleep();gf1.eat();}
}APL和apl帮助文档
应用程序编程接口
使用帮助文档
1、打开帮助文档
2、点击显示,并找到索引下面的输入
3、在输入框中输入类名并点击显示
4、查看类所在的包
5、查看类的描述
6、查看构造方法
7、查看成员方法
字符串
java.lang.String类代表字符串,Java程序中的所有字符串文字都为此类的对象
String name="abaaba";
String schoolName="abaaba";字符串不能发生改变,它们的值在创建后不能被更改
字符串方法
public String()----创建空白字符串,不含任何内容
public String(String original)----根据传入的字符串,创建字符串对象
public String(char[] chs)----根据字符数组,创建字符串对象
public String(byte[] chs)----根据字节数组,创建字符串对象
//1、使用直接赋值的方式获取一个字符串对象
String s1="abc";
System.out.println(s1);//2、使用new的方式来获取一个字符串对象
//空参构造:可以获取一个空白的字符串对象
String s2=new String();
System.out.println("@"+s2+"!");//传递一个字符串,根据传递的字符串内容再创建一个新的字符串对象
String s3= new String(original:"abc");
System.out.prinln(s3);//传递一个字符串数组,根据字符串数组的内容再创建一个新的字符串对象
char[] chs={'a','b','c','d'};
String s4= new String(chs);
System.out.println(s4);//传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
byte[] bytes={97,98,99,100};
String s5 =new String ();
System.out.println(s5);
//应用场景:以后在网络当中传输的数据其实都是字节信息
//我们一般要把字节信息进行转换,转成字符串,此时就要用到这个构造了改变字符串内容：
将字符串改变为字符的数组，字符数组是可以改变的，改变完字符数组以后再转为字符串。
public String() 创建空白字符串,不含任何内容
public String(String original) 根据传入的字符串,创建字符串对象
public String(char[] chs)根据字符数组,创建字符串对象
public String(byte[] chs)根据字节数组,创建字符串对象创建String对象
String name="尼古拉斯.阿伟";
String s1=new String();当使用双引号直接赋值时,系统会检查该字符串在串池中是否存在
不存在:创建新的
存在:复用
每new一次就是在堆内存里开辟一个新的空间
比较方法
==号的比较
如果是基本数据类型,比较的则是值
如果是引用数据类型,比较的则是地址值
String s1="abc";
String s2="abc";
System.out.println(s1==s2);//trueString s1=new String("abc");//记录堆里面的地址值
String s2="abc";//记录的是串池中的地址值
System.out.println(s1==s2);//falseequals
引用数据类型的比较
boolean equals(要比较的字符串)
equalsIgnoreCase
boolean equalsIgnoreCase(要比较的字符串)忽略大小写的比较
字符串的遍历
//1、键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("");
String str = sc.next();
//2、进行遍历
for(int i=0;i<str.length();i++){char c = str.charAt(i);System.out.println(c);
}StringBuilder
StringBuilder可以看成是一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率
构造方法
public StringBuilder()-----创建一个空白可变字符串对象，不含有任何内容
public String Builder(String str)----根据字符串的内容，来创建可变字符串对象
常用方法
public String Builder append(任意类型)----添加数据，并返回对象本身
public StingBuilder reserse()-----反转容器中的内容
public int length()----返回长度(字符出现的个数)
public String toString()----（通过toString（）就可以实现把StringBuilder转换为String）
StringBuilder sb = new StringBuilder("abc");
sb.append(1);
sb.append(2.3);
sb.append(true);
System.out.println(sb);
//打印：
//因为StringBuilder是java已经写好的类
//java在底层对他做了一些特殊处理
//打印对象不是地址值而是属性值链式编程：
当我们在调用一个方法的时候，不需要用变量接受他的结果，可以继续调用其他方法
int len=getString().substring(1).replace(target:"A",replacement:"Q").length();
System.out.println(len);StringJoiner
StringJoiner和StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的
提高字符串的操作效率，而且代码编写的特别简洁，但是目前市场上很少有人用
int[] arr={1,2,3};
StringJoiner sj= new StringJoiner(",","[","]");
for(int i=0;i<arr.length;i++){sj.add(arr[i]+"");
}
System.out.println(sj);//[1,2,3]构造方法
public StringJoiner(间隔符号)----创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner(间隔符号，开始符号，结束符号)----创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号
成员方法
public StringJoiner add()----添加数据，并返回对象本身
public int length()----返回长度（字符出现的个数）
public String toString()----返回一个字符串（该字符串就是拼接之后的结果）
字符串原理
1、字符串存储的内存原理
直接复制会复用字符串常量池中的
new出来不会复用，而是开辟一个新的空间
2、==号比较
基本数据类型比较数据值
引用数据类型比较地址值
3、字符串拼接的底层原理
拼接的时候没有变量，都是字符串
触发字符串的优化机制
在编译的时候就已经是最终结果了
String s = "a"+"b"+"c";
System.out.println(s);上述文件编译成class文件
String s = "abc";
System.out.printIn(s);字符串拼接的时候有变量参与：
String s1="a";
String s2 = s1 + "b";
String s3 = s2 + "c";集合
数组的长度固定，而集合的长度可变，自动扩容
数组能存储我基本数据类型和引用数组类型，而集合可以存引用数据类型，但是如果放入基本数据类型需要将其转换为包装类
//创建集合的对象
//泛型：限定集合中存储数据的类型
ArrayList<String> list = new ArrayList<String>();
//or
//此时我们创建的是ArrayList的对象，而ArrayList是java已经写好的一个类
//这个类在底层做了一些处理
//打印对象不是地址值，而是集合中存储的数据内容
//在展示的时候会拿【】把所有的数据进行包裹
ArrayList<String> list = new ArrayList<>();增：boolean add（E e）----添加元素，返回值表示是否添加成功
删：boolean remove（E e）----删除指定元素，返回值表示是否删除成功
E remove （int index）----删除指定索引的元素，返回被删除的元素
改：E set（int index，E e）----修改指定索引下的元素，返回原来的元素
查：E get（int index）----获取指定索引的元素
int size（）----集合的长度，也就是集合中元素的个数
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("aaa");
list.add("bbb");
list.add("ccc");
//删除元素
//删除值
boolean result1 = list.remove(o:"aaa");
System.out.println(result1);//trueboolean result2 = list.remove(o:"ddd");
System.out.println(result2);//false
//索引值删除
String str=list.remove(index:0);
System.out.println(str);//aaa//修改元素
String result =list.set(1,"ddd");
System.out.println(result);//aaa//查询元素
String s = list.get(0);
System.out.println(s);//aaa//遍历
for(int i=0;i<list.size();i++){String str = list.get(i);System.out.println(str);
}包装类
byte----Byte
short----Short
char----Character
int----Integer
long----Long
float----Float
double----Double
boolean----Boolean
