近期java学习

注释

在程序上方添加说明信息

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);//true

String s1=new String("abc");//记录堆里面的地址值
String s2="abc";//记录的是串池中的地址值
System.out.println(s1==s2);//false

equals
引用数据类型的比较
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);//true

boolean 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