Java笔记

清蒸奥利给

已于 2023-11-02 17:37:37 修改

阅读量32

点赞数

文章标签： java 笔记开发语言

于 2023-11-02 10:53:37 首次发布

本文链接：https://blog.csdn.net/qq_52572689/article/details/134176846

版权

jdk的安装以及环境的搭建

在资源中下载开发环境

第一行Java代码

在控制台上输出HelloWorld

public class HelloWorld{
		public static void main(String[] args){
			System.out.println("HelloWorld");
		}
	}

数据类型

基本数据类型

整型：byte short int long 位数从8 到16 到32 到64位

浮点型:float double 单精度和双精度，一般常用double

字符型:char 存储单个字符

布尔型:boolean 表述逻辑关系，True 或者False

引用数据类型

类将一个对象封装成一个类，类里包含着这个对象的属性

接口

数组

定义变量

定义变量语法格式：数据类型变量名 = 值；

如：int num = 6;

类型转换

在实际使用中由于各种因素可能会涉及到数据类型之间的转换，转换大体分为两种类型：自动转换以及强制转换；

类型的大小主要是 boolen(0或者1)<char=byte(8位)<short(16位)<int(32位)<long(64位)<float<double

自动转换：小类型转换为大类型不会存在超出大类型的数据范围的问题

如：byte a = 5;

int b = a;

强制类型转换：比如在int转换为byte，因为int的最大长度大于byte的最大长度，在进行转换的时候被认为是不安全的，但我们人为开发过程中，知道变量的大小，在保证转换为小类型数据时不会存在长度问题时，进行强制转换;语法格式为：int a = 5; byte b = (byte) a;

程序流程控制

流程控制语句

分支 if——else

选择 switch；if；if-else；if-else if-else

循环 for；while

面向对象

面向对象的三大要素：封装，继承，多态

封装

在开发过程中，需要描述一个对象，他可能会有各种属性以及需要进行的一些操作，在分散进行时不太紧凑且不利于后面的开发；于是需要进封装

比如人有姓名，年龄，性别，身高体重等等的属性

package demo;

public class person {
    public int age;
    public String name;
    public String address;
    public char sex;
}

继承

多态

集合

集合也属于是容器，容器里可以存入各种类型的数据，不要求一个容器内的数据类型必须相同，但日常开发过程中一个容器内的数据类型还是尽量保持一致。

List

主要学习了两种List，ArrayList和LinkedList

ArrayList：继承了Collection类；顺序List，存入顺序与整体取出时的顺序一致，允许存入重复的元素；有各种方法可以满足各种开发需求；适合于顺序存储的情况，他支持插入元素，但是在数据量较大时，在头部插入的效率不太高，一般只用于容量大小不变的情况。

在创建ArrayList时，ArrayList arraylist = new ArrayList();创建的容器容量为10，在超过10之后，他会自动扩容，自动扩容为后面的底层里的东西。

存在的问题：在下面代码的注释中也有写到，在使用普通类型正常常进行变量命名时候不会存在问题，但是在添加到容器不是存入创建好的有变量名的自定义变量（实例化类）而是现场new出来的(即匿名对象)，在后续的contains进行使用时会因为equals的底层代码的比较有问题呢从而对判断的结果产生错误的反馈。

问题的解决：1.创建对象时不要创建匿名对象； 2.如果必须使用自定义对象的匿名对象，要看底层的contains的底层代码，是通过对象的equals方法循环判断是否相同来实现，而自定义对象的equals方法是从Object类继承来的，为了满足我们的需求需要重写继承来的equals方法；重写equals方法又要求重写hashCode方法来保持同一个类的对象具有相同的hashCode

//先实现一个类，用于存入到容器内
package com.zx.test;

public class Person {
    private int id;
    private String name;
    private int age;
    private char sex;

    public Person() {
    }
    
    //需要重写从Object类继承的equals方法
    //因为contains方法的逻辑是使用equals
    //但是普通数据类型的equals方法与自定义数据类型的不同
    @Override
    public boolean equals(Object obj) {
        //要注意将传入的对象强转为本类的类型
        Person p = (Person) obj;
        if (this.id != p.id) return false;
        if (this.name != p.name) return false;
        if (this.age != p.age) return false;
        if (this.sex != p.sex) return false;
        return true;
    }

    public Person(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Person(int id, String name, int age, char sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

package demo20231102;

import com.zx.test.Person;
import java.util.ArrayList;

public class Equals {
    public static void main(String[] args) {
        /*
        ArrayList 的 contains方法存在一定的问题
        在正常的参数命名方式下，一个对象对应于一个参数名
        提供 contains方法可以提供整体来比较

        而使用匿名命名的方式来添加到ArrayList的变量
        在使用contains时无法整体比较
        由于contains调用的是对象的equals方法
        故而需要在对象内重写equals方法
        否则提供继承Object而来的equals方法不能正确比较
         */

        Person person = new Person("wang",15,'s');
        Person person1 = new Person("zhang",35,'s');
        Person person2 = new Person("li",25,'s');
        ArrayList Per = new ArrayList();
        Per.add(person);
        Per.add(person1);
        Per.add(person2);
        
        //结果为True
        System.out.println(Per.contains(person));

        Per.clear();
        Per.add(new Person("wang",15,'s'));
        Per.add(new Person("sa",85,'w'));
        Per.add(new Person("aa",55,'8'));
        System.out.println(Per);

        //在没有重写对应类里的equals方法时，结果为false
        //重写equals后，改变了contains调用时的判别逻辑，结果为True
        System.out.println(Per.contains(new Person("wang",15,'s')));
    }
}

LinkedList：同样继承了Collection；链式存储，存入顺序与整体取出的顺序一致，允许存入重复的元素；同样支持大量的方法接口；一般用于需要频繁进行元素的插入操作，可以方便的进行元素的插入，且不会有太大的开销