我的周记3

标准的JavaBean类(javabean翻译过来是对象的意思)
1. 类名需要见名知意
2. 成员变量使用private修饰
3. 提供至少两个构造方法
    无参构造方法
    带全部参数的构造方法
4. 成员变量
    提供每一个成员变量对应的setXxx()/getXxx()
    如果还有其他行为,也需要加上

成员变量:类中方法外的变量,有默认初始值,在整个类中都有效,随创建的对象而存在,随着对象的消失而消失
局部变量:方法中的变量,无初始值,使用前需要完成赋值,只在当前方法中有效,随方法的调用而存在,随方法运行的结束而消失

类就是一个数据类型
方法:
    public void attack (Role role) /* 这里的Role role 指的是对象引用，语法是"类名  对象的引用变量" / Role是类名，role是形参，Role role合起来类似于前面创建一个对象 / 这里的Role role：是指调用本身的类Role并定义了为参数role(可以看文件名) */

键盘录入(补充):
//键盘录入的两套体系不能混用的
//弊端: 先用nextInt类,再用nextLine会导致下面的nextLine接收不到数据(学类型转换前)
第一套体系(遇到空格,制表符,回车键就停止接收 . 这些符号后面的数据就不会接受了):
    nextInt(); 接收整数
    nextDouble(); 接收小数
    next(); 接收字符串
第二套体系(可以接收空格,制表符,遇回车键才停止接收数据):
    nextLine(); 接收字符串

不把c当成对象名，而是一个变量，存放的new出的对象的地址值，这里new了三次，就是三个地址值被同一个变量接收，但在被下一个地址覆盖前已经赋值给了数组

String类
字符串的内容是不会发生改变的，它的对象在创建后不能被更改
创建String对象的两种方式
直接赋值：String name = "上杉绘梨衣" ；
new：
构造方法                说明
public String()                创建空白字符串,不含任何内容
public String(String original)    根据传入的字符串,创建字符串对象
public String(char[] chs)        根据字符数组,创建字符串对象
public String(byte[] chs)        根据字节数组,创建字符串对象
范例：
//1.使用直接赋值的方式获取一个字符串对象
    String s1 = "abc";
    System.out.println(s1);//abc
//2.使用new的方式来获取一个字符串对象
//空参构造:可以获取一个空白的字符串对象
    String s2 = new String();
    System.out.println("@" + s2 + "!");//@!
//传递一个字符串,根据传递的字符串内容再创建一个新的字符串对象
    String s3 = new String( "abc");
    System.out.println(s3);//abc
//传递一个字符数组,根据字符数组的内容再创建一个新的字符串对象
    char[] chs = {'a', 'b' , 'c', 'd');
    String s4 = new String(chs);
    System.out.println(s4);//abcd
//应用场景:以后在网络当中传输的数据其实都是字节信息
//我们一般要把字节信息进行转换,转成字符串,此时就要用到这个构造了。
    byte[] bytes = {97, 98, 99, 100};
    String s5 = new String(bytes);
    System.out.println(s5);//abcd

//（）中的是索引,String 变量名是用来接收数据的，如果变量已经定义，就不用加String
● String 变量名 = 截取数据的对象名.substring(int beginlndex, int endlndex)    截取
注意点:包头不包尾,包左不包右，只有返回值才是截取的小串
● String 变量名 = 截取数据的对象名.substring(int beginlndex)    截取到末尾
● String 变量名 = talk.replace("旧值","新值")    替换
注意点:只有返回值才是替换之后的结果

== 号比的到底是什么?
基本数据类型                        引用数据类型
int a = 10;                            String s1 = new String("abc");
int b = 20;                        String s2 = new String("abc");
System.out.println(a == b); //false        System.out.println(s1 == s2); //false
基本数据类型比较的是数据值        引用数据类型比较的是地址值

字符串比较
● boolean equals方法(要比较的字符串)        完全一样结果才是true,否则为false
● boolean equalslgnoreCase(要比较的字符串)    忽略大小写的比较
范例：
//比较字符串对象中的内容是否相等
boolean result1 = s1.equals(s2);
System.out.println(result1);
//比较字符串对象中的内容是否相等,忽略大小写
//一和壹 这不行
//忽略大小写只能是英文状态下的a A
boolean result2 = s1.equalsIgnoreCase(s2);
System.out.println(result2);//true

遍历字符串：
● public char charAt(int index):根据索引返回字符
● public int length():返回此字符串的长度
● 数组的长度:数组名.length
● 字符串的长度:字符串对象.length()
使用StringBuilder的场景：
1. 字符串的拼接
2. 字符串的反转
StringBuilder构造方法
方法名                        说明
public StringBuilder()            创建一个空白可变字符串对象,不含有任何内容
public StringBuilder(String str)        根据字符串的内容,来创建可变字符串对象

StringBuilder常用方法
方法名                            说明
public StringBuilder append(任意类型)    添加数据,并返回对象本身
public StringBuilder reverse()            反转容器中的内容
public int length()                    返回长度(字符出现的个数)
public String toString()                通过toString()就可以实现把StringBuilder转换为String
范例：
//1.创建对象
StringBuilder sb = new StringBuilder("abc");
//2.添加元素
/*sb.append(1);
sb.append(2.3);
sb.append(true) ;//abc12.3true*/
//反转
sb.reverse();//cba
//获取长度
int len = sb.length();//3
System.out.println(len);
//打印
//普及:
//因为StringBuilder是Java己经写好的类
//java在底层对他做了一些特殊处理。
//打印对象不是地址值而是属性值。
System.out.println(sb);

//1.创建对象
StringBuilder sb = new StringBuilder();
//2.添加字符串
sb.append("aaa");
sb.append("bbb");
sb.append("ccc");
sb.append("ddd");
System.out.println(sb);//aaabbbcccddd
//3.再把StringBuilder变回字符串
String str = sb.toString();
System.out.println(str);//aaabbbcccddd

链式编程：
//链式编程:
//当我们在调用一个方法的时候,不需要用变量接收他的结果,可以继续调用其他方法
public static void main (String [] args){
int len = getString().substring(1).replace( target: "A", replacement: "Q").length();
System.out.println(len);//输入abc ，结果为2
}
public static String getString(){
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串”);
String str = sc.next();
return str;
}
所以：
sb.append("aaa").append("bbb").append("ccc").append("ddd");

StringJoiner
StringJoiner的构造方法
方法名                                            说明
public StringJoiner(间隔符号)                            创建一个StringJoiner对象,指定拼接时的间隔符号
public StringJoiner(间隔符号,开始符号,结束符号)        创建一个StringJoiner对象,指定拼接时的间隔符号、开始符号、结束符号
范例：
StringJoiner sj = new StringJoiner(" --- ");                1 --- 2 --- 3
StringJoiner sj = new StringJoiner(",","[","]");            [1, 2, 3]

StringJoiner 的成员方法
方法名                                    说明
public StringJoiner add(添加的内容)            添加数据,并返回对象本身
public int length()                            返回长度(字符出现的个数)
public String toString()                        返回一个字符串(该字符串就是拼接之后的结果)

范例：
//1.创建对象
StringJoiner sj = new StringJoiner( delimiter: ", ", prefix: "[", suffix: "]");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc"); 
int len = sj.length();
System.out.println(len);//15，包括空格，符号，字母等
//3.打印
System.out.println(sj);//[aaa, bbb, ccc]
String str = sj.toString();
System.out.println(str);//[aaa, bbb, ccc]

字符串原理小结
1. 扩展底层原理:字符串存储的内存原理
● 直接赋值会复用字符串常量池中的
● new出来不会复用,而是开辟一个新的空间
2. 扩展底层原理 :== 号比较的到底是什么?
● 基本数据类型比较数据值
● 引用数据类型比较地址值
3. 扩展底层原理:字符串拼接的底层原理
● 如果没有变量参与,都是字符串直接相加,编译之后就是拼接之后的结果,会复用串池中的字符串。
● 如果有变量参与,会创建新的字符串,浪费内存。
4. 扩展底层原理:StringBuilder提高效率原理图
● 所有要拼接的内容都会往StringBuilder中放,不会创建很多无用的空间,节约内存
5. 扩展底层原理:StringBuilder源码分析
● 默认创建一个长度为16的字节数组                                                      
● 添加的内容长度小于16,直接存
● 添加的内容大于16会扩容(原来的容量*2+2)
● 如果扩容之后还不够,以实际长度为准
                  
                   
集合：
<>中是泛型：限定集合中存储的数据类型
集合和数组的对比
● 长度    数组长度固定    集合长度可变
● 存储类型    数组    可以存基本数据类型，可以存引用数据类型
集合    可以存引用数据类型        基本数据类型需要转换成包装类才能储存在集合中

//创建一个集合
ArrayList<String> list = new ArrayList<>();
ArrayList<Student> list = new ArrayList<>();
//此时我们创建的是ArrayList的对象,而ArrayList是java己经写好的一个类
//这个类在底层做了一些处理
//打印对象不是地址值,而是集合中存储数据内容
//在展示的时候会拿[]把所有的数据进行包裹
//添加元素
list.add("aaa");
list.add("aaa");
list.add("bbb");
list.add("ccc");
//删除元素
boolean result1 = list.remove("aaa");
System.out.println(result1);
boolean result2 = list.remove("ddd");
System.out.println(result2);
String str = list.remove(2);
System.out.println(str) ;
//修改元素
String result = list.set(1, "ddd");
System.out.println(result) ;
//查询元素
String s = list.get(0);
System.out.println(s) ;
//遍历
for (int i = 0; i < list.size(); i++) 
{
//i 索引
//list.get(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

范例：
//底层原理:
//因为在实际开发中,-128~127之间的数据,用的比较多。
//如果每次使用都是new对象,那么太浪费内存了
//所以,提前把这个范围之内的每一个数据都创建好对象
//如果要用到了不会创建新的,而是返回已经创建好的对象。
    Integer i6 = Integer.valueOf(127);
    Integer i7 = Integer.valueOf(127);
    System.out.println(i6 =6 == i7);//true

    Integer i8 = Integer.valueOf(128);
    Integer i9 = Integer.valueOf(128);
    System.out.println(i8 ==i9);//false

public static boolean contains(ArrayList<User> list, String id){
for (int i = 0; i < list.size(); i++) {
User u = list.get(i);
String uid = u.getId();
if(uid.equals(id) ){
//如果找到了直接返回true
return true;
}

//技巧:
//如果我们要返回多个数据,可以把这些数据先放到一个容器当中,再把容器返回
//集合 数组

static（共享）：
表示静态,是Java中的一个修饰符,可以修饰成员方法,成员变量；
1. 被static修饰的成员变量,叫做静态变量
特点:
● 被该类所有对象共享
●不属于对象，属于类
●随着类的加载而加载的，优先于对象出现；
调用方式:
● 类名调用(推荐)
● 对象名调用

被static修饰的成员方法,叫做静态方法
特点:
● 多用在测试类和工具类中
● Javabean类中很少会用
调用方式:
● 类名调用(推荐)
● 对象名调用

static的注意事项
●静态方法只能访问静态变量和静态方法
●非静态方法可以访问静态变量或者静态方法,也可以访问非静态的成员变量和非静态的成员方法
●静态方法中是没有this关键字

总结:静态方法中,只能访问静态。
    非静态方法可以访问所有。
    静态方法中没有this关键字

重新认识main方法
public class HelloWorld 
{
    public static void main(String[] args)
    {
        System.out.println("HelloWorld");
    }
}
    ●public：被JVM调用,访问权限足够大
    ●static：被JVM调用,不用创建对象,直接类名访问，因为main方法是静态的,所以测试类中其他方法也需要是静态的。
    ● void：被JVM调用,不需要给JVM返回值
    ● main：一个通用的名称,虽然不是关键字,但是被JVM识别
    ● String[] args：以前用于接收键盘录入数据的,现在没用