目前java学习笔记

idea快捷键

main/psvm，sout.....

CTRL+D复制当前数据到下一行

CTRL+Y/X删除所在行

CTRL+ALT+L格式化代码（整齐化代码）

ALT+SHIFT+上箭头    向上移动当前行代码；

path环境变量是用于记住程序路径方便在命令行窗口的任意目录启动程序

整数和小数在程序中的写法不变

字符在程序中必须要用单引号，单引号中有且只能有一个字符

字符串用双引号，双引号间允许什么都没有；

变量是用来储存一块数据的本质是内存中的一块区域

内存中的区域分为方法区和栈和堆；

标识符以字母，数字，美元符，下划线组合而成且数字不能当作开头；

面向对象中

this是一个变量，可以用在方法中，用来拿到当前对象；

哪个对象调用这个方法，this就会拿到这个对象

this用来解决对象的成员变量与方法内部变量（形参）的名称一样时，导致访问冲突问题的

例如this.score>score

面向对象在构造器中的执行原理

        先把test类提到方法区里来再把main方法提到栈里面去执行
                再把学生类也加载到方法区里去
        new出来的对象都存放在堆里面，在堆里面开辟一块区域（一张学生表）；
        然后按照学生类的要求开辟一些变量空间（拥有自身的16进制地址）
                对象里还有一些类的地址信息（指向创建出这个对象的类）
        而main方法里的s1s2变量存储着堆中对象的地址；
        一旦一个在堆内存中的对象没有任何对象指向它它就变成了垃圾对象
                java中存在自动垃圾回收机制，会自动清除垃圾对象，程序员不用担心；
        
构造器是一种特殊的方法，名字必须与所在class的名字一样而且不能声明返回值类型
        构造器的特点：当每次去new对象时
                例如
                student s=new student();
        new student是告诉计算机创建出一个学生对象
                而后面的()是用来告诉前面的学生对象去调用哪一个构造器来执行
            例如
                package oriented;

        public class student3 {
            //构造器可以在一个class中存在多个（参数列表不同）
            public student3(){
                System.out.println("无参数构造器被触发执行了");
            }
            public student3(double score,String name){
                System.out.println("有参数构造器被触发执行了");
            }
        }
        "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
                package oriented;

        public class test3 {
            public static void main(String[] args) {
                student3 s1=new student3();
                System.out.println(s1);
                student3 s2=new student3(99.9,"A");
                System.out.println(s2);
            }
        }
    }

这样前后分别显示：无参数构造器被触发执行了，和：有参数构造器被触发执行了

类似student s1=new student();

s1.xxxxxx;

这些必须在main函数中运行

面向对象学习自我总结

1，写的东西限制在一个包下，同一个包下可以自动访问相应对象

2.

public void printthis(){
    System.out.println(this);
}

this变量可以拿到相应的地址

并且

public void printpass(double score){
    if (this.score>score){
        //this.指定访问当前对象的成员变量

3.系统会自动存在一个无参数构造器但当建立一个有参数的构造器后必须手动建立一个无参数构造器

构造器名字必须与所在类的名字一样而且不能写返回值类型，创建完毕之后就不能叫作一个方法而要叫做一个构造器。

4.不应该随意暴露对象的成员变量，要做到合理隐藏合理暴漏；

public 暴露

private 隐藏

要有封装意识，把所有成员变量全部隐藏起来，只合理暴漏其中一部分比如setxxx和getxxx以及构造器；

5.实体JavaBean

（1）必须私有成员变量并为每个成员变量提供get set方法

（右键然后选择generate再选择其中的getter and setter选项去快速创建get set方法；）

（2）必须为类提供一个公开的无参数构造器

（generate里面同样可以快速创建构造器）

package bijiben;

public class test {
    public static void main(String[] args) {


        student s1 = new student("小华", 100);
        student s2=new student();
        s2.setName("小华");
        s2.setScore(100);
        System.out.println(s1.getScore());
        System.out.println(s1.getName());
        System.out.println(s2.getScore());
        System.out.println(s2.getName());
    }
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~·

package bijiben;

public class student {
    private String name;
    private double score;

    public student() {
    }

    public student(String name, double score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}

由上方代码验证得无论是setxxxx还是构造器输入的内容都能被getxxx输出；

实体类的应用场景：实体类只负责数据存储，对数据的处理则交由其它类来完成，以实现数据和业务处理相分离。

6.类名  对象名=new 类名（）；//以此得到类的对象

7.定义类的格式

1.成员变量

2.成员方法

3.构造器

4.代码块

5.内部类

8.定义类注意事项

（1）类名首字母大写，有意义，满足驼峰格式，不要用关键字，合法的标志符

（2）一个java文件中可以定义多个类，但只有一个类是由public修饰的而且public修饰的类名必须与Java代码的文件名相同，否则报错；

（3）成员变量不建议给初始值存在默认值；

9.创建对象

（1）类名 对象名=new 构造器（）；

（2）对象怎么使用？对象名.成员方法or对象名.成员变量

10.构造器的作用：初始化一个类的的对象，并返回这个对象的地址

详细格式：修饰符 类名（形参）{..............}

无参数构造器：初始化一个类的对象，并返回这个对象的地址，里面的数据都是默认值

有参数构造器：初始化一个类的对象，并返回这个对象的地址，同时为对象赋值

调用构造器：类名 对象名 =new 构造器；

package bijiben;

import java.util.ArrayList;

public class 常用api总结 {
    //api全称是应用编程窗口
    //1.String类
//    String是字符串类型，它定义的变量可以直接指向字符串对象
    //且是不可变字符串对象
//    创建字符串对象的方式1.String name=”黑马“2.new构造器得到字符串对象
    //双引号定义的字符串对象存在于堆内存中的常量池中，相同的内容只会存储一份
    //new出来的字符串对象每new一次都会在堆内存中构造一个字符串对象，可以内容重复
    //包是分别管理程序的
    //调用其他包下的程序，必须在当前程序中导包，才可以访问    ：导报格式：import 包名.类名;
    /*String name="小华";
    name = "100";
        System.out.println(name);//输出100
        但这个100是重新在常量池中创建了一个对象，原本的”小华“对象并没有改变，所以String是不可变字符串
    String rs1=new String();
        System.out.println(rs1);//字符串对象里面的内容为""

        new String("小华");

    char[] arr={'a','b','c'};
    String rs2 =new String(arr);
        System.out.println(rs2);

    byte[] brr ={97,98,99,100};
    String rs3=new String(brr);
        System.out.println(rs3);
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`");
    //使用String方法
    String code = "abcdefg";
    //1.获取字符串的长度
        System.out.println(code.length());
    //2.提取字符串中某个索引位置的字符
        System.out.println(code.charAt(1));
    //3.字符串的遍历
        for (int i = 0; i < code.length(); i++) {
        System.out.print(code.charAt(i));
    }
    //4.将字符串转化为字符数组
    char[] a=code.toCharArray();
        System.out.print('[');
        for (int i = 0; i < a.length; i++) {
        System.out.print(i<6?a[i]+",":a[i]);
    }
        System.out.println(']');
    //5.判断字符串内容，内容一样则返回true（比较字符串内容）
    String s1=new String("");
    String s2=new String("");
        System.out.println(s1==s2);//会返回false，因为‘==’号会查看地址是否一样
        System.out.println(s1.equals(s2));//会返回true

    //6.判断字符串内容，忽略大小写
    String s3=new String("56FGas");
    String s4=new String("56fgAS");
        System.out.println(s3.equals(s4));//false
        System.out.println(s3.equalsIgnoreCase(s4));//true

    //7.截取字符串内容（包前不包后）
    String s5=new String("java是最好的编程语言之一");
    String rs=s5.substring(0,12);
        System.out.println(rs);

    //8.截取字符串内容（从当前位置一直到字符串末尾）
    String rs4=s5.substring(5);
        System.out.println(rs4);

    //9.把字符串中的某个内容替换成新内容
    String rs5="这个电影是个垃圾，垃圾电影！";
    String rs6=rs5.replace("垃圾","**");
        System.out.println(rs6);

    //10.判断字符串中是否含有某个关键字
    String rs7="java是最好的语言之一";
        System.out.println(rs7.contains("java"));//true
        System.out.println(rs7.contains("Java"));//对大小写敏感输出false
        System.out.println(rs7.contains("java2"));//必须完全重合，输出false

    //11.判断字符串是否以某个字符或者字符串开头
    String rs8="庞炳*********";
        System.out.println(rs8.startsWith("庞"));//true
        System.out.println(rs8.startsWith("庞炳"));//true
        System.out.println(rs8.startsWith("庞1"));//false

    //12.将一个字符串分割成多个字符串，放到一个字符串数组中返回；
    String rs9="A,B,C,D,E";
    String[] name1=rs9.split(",");
        for (int i = 0; i < name1.length; i++) {
        System.out.println(name1[i]);
    }

        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");*/
    //只要是以”  “方式写出的字符串对象都会放在堆内存的字符串常量值中进行存储，且相同内容的字符串只存储一份
    //String对象的内容是不可改变的，它被人们称之为不可变字符串对象；
    //通过new方式创建的字符串对象，每new一次就会产生一个新的对象储存在堆中
    //String s2=new String("abc")
    //上方代码创建了两个对象，一个是由”“方式创建对象存放在了堆内存中，另一个是由new方式创建对象存放在堆内存中

    //String s1="abc";
    //String s2="ab";
    //String s3=s2+"c";   这个上存放在堆中而不在常量池中，因为上经过了运算，而运算的结果不会放在常量池中
    //String s4=”a“+”b“+”c“；s4==s1结果为true  因为Java中存在编译优化机制会将"a"+"b"+"c"直接转化为”abc“

    //ArrayList
    //集合代表一种容器类似于数组
//    集合容器中存储的是堆内存中的地址
    //特点：大小可变，类型不固定，功能更强，适合做元素个数不确定，同时存在增删操作的业务场景
    //构建ArrayList的对象代表一个集合容器存储数据1.public ArrayList（）；2.ArrayList List=new ArrayList（）；
    //ArrayList代表一种集合（一种容器，类似于数组）
    //ArrayList是集合中最常用的一种
//因为数组定义并完成启动后，长度就固定了，不利于用户在购物车内增删商品这类操作
    //而集合最显著的特点就是大小可变
    //容器会有哪些方法：增删改查
//        1.创建ArrayList集合对象
// 构造器：
    // 1.ArrayList()构造一个初始容量为10的空列表
/*    ArrayList<String> List = new ArrayList<>();
        List.add("黑马");
        List.add("666");
        List.add("666");
        List.add("pang");
//        System.out.println(List);


    //向集合中某个索引位置添加一个数据
        List.add(1,"manks");
        System.out.println(List);


    //获取某个索引位置的元素值
    String rs=List.get(1);
        System.out.println(rs);

    //获取集合的大小（返回集合中存储的元素个数）
        System.out.println(List.size());

    //删除索引处的元素，并返回该元素
    String name=List.remove(1);
        System.out.println(name);
        System.out.println(List);

    //删除指定元素，返回是否删除成功
        System.out.println(List.remove("666"));
        System.out.println(List);
    //有多个相同元素它删除并返回第一个

    //修改指定索引处元素,并返回修改前索引位置处的数据
        System.out.println(List.set(1, "nb"));
        System.out.println(List);*/

    //ArrayList<E>中E代表可以添加任意类型
    //ArrayList遍历并删除元素
    //下面是例题
/*
package ArrayListDemo;

import java.util.ArrayList;

    public class ArrayListDemo2 {
        public static void main(String[] args) {
            ArrayList<String> list=new ArrayList<>();
            list.add("java入门");
            list.add( "宁夏枸杞");
            list.add( "云南枸杞");
            list.add( "河南枸杞");
            list.add( "山东枸杞");
            list.add( "北京枸杞");
            list.add( "黑枸杞");
            list.add( "人字拖");
            System.out.println(list);
            System.out.println(list.remove("枸杞"));
            System.out.println(list);
//方法1
*/
/*        for (int i = 0; i < list.size(); i++) {
            String sc=list.get(i);
            if (sc.contains("枸杞")){
                list.set(i,null);
            }
        }
        int a=list.size();
        for (int i = 0; i < a; i++) {
            list.remove(null);
        }
        System.out.println(list);*//*

//方法2
*/
/*        for (int i = 0; i < list.size(); i++) {
            String sc=list.get(i);
            if (sc.contains("枸杞")){
                list.remove(i);
                i--;
            }
        }
        System.out.println(list);*//*


//方法3
            for (int i = list.size()-1; i >=0; i--) {
                String sc=list.get(i);
                if (sc.contains("枸杞")){
                    list.remove(i);
                }
            }
            System.out.println(list);
        }
    }
*/

}