Java小白笔记

秃兔.

已于 2024-05-28 08:35:34 修改

阅读量373

点赞数 2

文章标签： java 笔记

于 2024-05-08 13:58:32 首次发布

本文链接：https://blog.csdn.net/m0_65512914/article/details/138540701

版权

1.JDK,JRE与JVM

JDK:是Java开发工具包，包括jvm虚拟机，核心类库，开发工具

JRE:是Java运行环境，包括核心类库，运行工具

JDK包含JRE,JRE 包含了JVM

2.面向对象

2.1类和对象

类是共同特征的描述，对象是具体的实例。

在Java中必须先设计类，才能获取对象。

类名满足驼峰模式。

public class phone {
    //属性（成员变量）
    String brand;
    double price;

    //行为（方法）
    public void call(){System.out.println("手机在打电话");}

    public void play(){System.out.println("手机在玩游戏");}


}

public class phoneTest {
    public static void main(String[] args) {
        //创建手机的对象
        phone p = new phone();

        //给手机赋值
        p.brand = "小米";
        p.price = 1999;

        //获取手机对象中的值
        System.out.println(p.brand);
        System.out.println(p.price);

        //调用手机的方法
        p.call();
        p.play();
    }
}

2.2封装

人画圆

对象代表什么，就得封装对应的数据，并提供数据对应的方法 （对象圆，半径是圆的属性，根据属性画圆，所以画圆是圆的方法）

人关门

门是自己关的（关门是门的方法）

封装的好处：告诉我们，如何正确设计对象的属性和方法

有什么事，找对象，调方法就行

被private修饰的成员只能在本类中才能访问。

public class Girl {
    //属性
    private String name;
    private int age;

    //针对每个私有化的成员变量，都要提供get和Set方法
    //set方法：给成员变量赋值
    //get方法：对外提供成员变量的值
    public void setName(String name) {
        //name = n;
    //局部变量表示测试类中调用方法传递过来的数据
    //等号的左边表示成员位置的name
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        if(a>=18&&a<=55){
            age=a;
        }else {
            System.out.println("非法参数");
        }
    }

    public int getAge() {
        return age;
    }

    //行为
    public void sleep(){System.out.println("女孩在睡觉");}

}

public class GirlTest {
    public static void main(String[] args) {
        //创建女孩的对象
        Girl girl = new Girl();

        //给女孩赋值
        girl.setName("小诗诗");
        girl.setAge(18);

        //获取女孩对象中的值
        System.out.println(girl.getAge());
        System.out.println(girl.getName());

        //调用女孩的方法
        girl.sleep();
    }
}

2.3this关键字和就近原则

局部变量和成员变量

就近原则：谁离我近，我就用谁

this的作用：可以区分局部变量和成员变量

2.4构造方法

如果没有构造方法系统会默认给出一个无参数的构造方法

如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载：带参构造无参构造方法名相同但参数不同

无论是否适用，都手动书写无参构造和带全部参数的构造方法

构造方法的作用：创造对象时，由虚拟机自动调用，给成员变量进行初始化

public class Student {
    private String name;
    private int age;

    //如果没写任何的构造方法，
    //那么虚拟机会给我们加一个构造方法
    public Student(){
        System.out.println("看看我运行了吗？");
    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;

    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        //创建对象，调用空的构造方法
        //Student s=new Student();

        Student s = new Student("zhangsan",23);
        System.out.println(s.getAge());
        System.out.println(s.getName());
    }
}

2.5标准的javabean类

①类名需要见名知意

②成员变量使用private修饰

③提供至少两个构造方法

无参构造方法

带全部参数的构造方法

④成员方法

提供每一个成员变量对应的setXxx()/getXxx()

快捷键

alt+insert/alt+Fn+insert

ctrl+d 向下复制一行

Ctrl+shift+/ 多行注释

ctrl+b

Shift+f6批量修改

fori正着遍历

forr倒着遍历

ctrl+alt+v

选中 Ctrl+b 查看源码

插件PTG 1秒生成标准Javabean

2.6对象内存图

面向对象-07-三种情况的对象内存图_哔哩哔哩_bilibili

两个对象的内存图

面向对象-07-三种情况的对象内存图_哔哩哔哩_bilibili

两个引用指向同一个对象

面向对象-07-三种情况的对象内存图_哔哩哔哩_bilibili

基本数据类型：数据值是存储在自己的空间中比较的是数据值

引用数据类型：数据值是存储在其他空间中比较地址值

this的本质：代表方法调用者的地址值

成员变量：类中方法外的变量

局部变量：方法中的变量

案例

思路：

1.创建一个长度为3的数组；

2.创建学生对象；
3.把学生对象添加到数组里

4.再次创建一个学生对象

5.唯一性判断

5.1 已存在--提示重复

5.2 不存在--添加学生对象

6.添加学生对象

6.1老数组已经填满；

6.2老数组没有填满

package code;

public class Student {
    private String name;
    private int id;
    private int age;

    //如果没写任何的构造方法，
    //那么虚拟机会给我们加一个构造方法
    public Student(){

    }
    public Student(String name,int age,int id){
        this.name=name;
        this.age=age;
        this.id=id;

    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
}

package code;

public class StudentTest {
    public static void main(String[] args) {
        Student[] arr = new Student[3];

        Student stu1 = new Student("zhangsan",23,1);
        Student stu2 = new Student("lisi",24,2);
        Student stu3 = new Student("wangwu",18,3);

        arr[0] = stu1;
        arr[1] = stu2;
        arr[2] = stu3;

        //要求1
        Student stu4 =new Student("zhaoliu",26,4);
        //唯一性判断
        boolean flag = contains(arr, stu4.getId());
        if (flag){
            System.out.println("当前id重复，请修改id后在进行添加");
        }else{
            int count = getCount(arr);
            if(count == arr.length){
                Student[] newArr=creatNewArr(arr);
                newArr[count]=stu4;

                //要求2
                printArr(newArr);
            }else{
              arr[count] = stu4;

              //要求2
                printArr(arr);
            }

        }





    }
    public  static  void  printArr(Student[] arr){
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            if(stu != null){
                System.out.println(stu.getId()+","+ stu.getAge()+","+stu.getName());
            }

        }
    }
    public  static  Student[] creatNewArr(Student[] arr){
        Student[] newArr = new  Student[arr.length+1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];

        }
        return newArr;
    }
    public static  int getCount(Student[] arr){
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null){
                count++;
            }

        }
        return count;
    }
    public static  boolean  contains( Student[] arr,int id){
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            int sid = stu.getId();
            if (stu != null) {
                if (sid == id) {
                    return true;
                }

            }
        }
        return  false;
    }
}

3.字符串

3.1API文档练习

3.2创建String对象的两种方式内存分析

3.3字符串的比较

public class Main {
    public static void main(String[] args) {
       String s1="Abc";
       String s2 = new String("abc");

       boolean result = s1.equals(s2);//不忽略大小写
        System.out.println(result);

        boolean result2 =s1.equalsIgnoreCase(s2);//忽略大小写
        System.out.println(result2);
        }

}

3.4用户登录练习

3.4遍历字符串

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str =sc.next();

        //进行遍历
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            System.out.println(c);


        }

        }

}

3.5统计字符个数

3.6字符串反转

3.7拼接字符串

3.8截取

包头不包尾

public class Main {
    public static void main(String[] args) {
        String sum="123456";

        String substring = sum.substring(0, 3);
        System.out.println(substring);//123

    }

}

3.8替换

public class Main {
    public static void main(String[] args) {
        String sum="123456";

        String replace = sum.replace("2", "*");
        System.out.println(replace);//1*3456

    }

}

3.9StringBuilder

是一个内容可变的容器

场景应用：字符串的拼接，字符串的反转

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

       StringBuilder sb = new StringBuilder("abc");
        //添加元素
       sb.append(1);
       sb.append(true);
        //反转
       sb.reverse();
       //获取长度
       sb.length();
        //把StringBuilder变回字符串
        String str =sb.toString()


        System.out.println(str);

    }

}

链式编程：当我们在调用一个方法时，不需要用变量接收他的结果，可以继续调用其他方法

对称字符串

拼接字符串

3.10StringJoiner

public class Main {
    public static void main(String[] args) {
        //1.创建一个对象，并指定中间的间隔符号
        //StringJoiner sj = new StringJoiner("---");
        StringJoiner sj = new StringJoiner(",","[","]");
        //2.添加元素
        sj.add("aaa").add("bbb");
        System.out.println(sj);



    }

}

3.11字符串原理

3.12调整字符串

public class Main {
    public static void main(String[] args) {
        String strA = "abcd";
        String strB = "cdab";

        boolean result = check(strA,strB);
        System.out.println(result);
    }


        public static  boolean check(String strA,String strB){
            for (int i = 0; i < strA.length(); i++) {
                strA = rotate(strA);
                if (strA.equals(strB)) {

                    return  true;
                }
            }
            return  false;
        }

        public static String rotate(String str){

            char first = str.charAt(0);
            String end = str.substring(1);
             return end+first;

        }

}

4.集合

public class Main {
    public static void main(String[] args) {
        //创建集合的对象
        //泛型<>：限定集合中存储数据的类型
        ArrayList<String> list = new ArrayList<String>();
        //打印对象不是地址值，而是集合中存储数据内容

        //成员方法 增删改查
        //添加元素
        boolean result = list.add("Aaa");
        System.out.println(result);//true
        System.out.println(list);//[Aaa]
        
        //删除元素
        boolean result2 = list.remove("Aaa");//true

        String remove = list.remove(0);//Aaa

        //修改元素
        String ddd = list.set(1, "ddd");
        
        //查询元素
        String s = list.get(0);
        
        //遍历  list.fori
        for (int i = 0; i < list.size(); i++) {
            
        }
    }
}

4.1添加学生对象并打印

4.2查找用户是否存在

package code;

public class User {
    //属性
    private String username;
    private String password;
    private String id;

    public User(){}

    public User(String id,String username,String password){
        this.id=id;
        this.username=username;
        this.password=password;

    }

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPassword() {
        return password;
    }
}

package code;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<>();

        User u1=new User("001","zhangsan","123");
        User u2=new User("002","zhaowu","123");
        User u3=new User("003","lisi","123");

        list.add(u1);
        list.add(u2);
        list.add(u3);

        boolean flag=con(list,"001");
        System.out.println(flag);;
    }

    //1.我要干什么 根据id找用户
    //2.我干这件事需要什么才能完成 list id
    //3.调用处时是否需要使用方法的结果 返回
    public static  boolean con(ArrayList<User> list,String id){
       return getIndex(list,id)>=0;
    }
    public static int getIndex(ArrayList<User> list,String id){
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            String uid = user.getId();
            if(uid.equals(id)){
                return  i;
            }
        }
        return -1;
    }


}

返回多个数据时可以把这些数据先放到一个容器里（集合数组）再把容器返回