java基础 万字总结

目录

Java 的语言特性

Java的第一个程序

Java的注释

pubilc class 和class的区别

标识符

字面值

 变量

关于变量的分类

 数据类型

 关于八种基本数据类型的默认值

数据类型--整数型

数据类型--浮点型

数据类型--布尔型

运算符

关于java中的“+”运算符

三元运算符：

控制语句

java

 java--方法

 java-面向对象（核心）

 java - 构造方法

 java - static

 java - this

 java - 方法覆盖

Java - 封装

 java - 继承

 java - 多态

 java - super

 java - final

 java - 抽象类

 java - 接口

抽象类和接口有什么区别

java - 数组

java - Object

java -- String

---

---

• Java 的语言特性

1.简单性       
2.面向对象    
3.可移植性
4.多线程
5.健壮性
6.安全性

• Java的第一个程序

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

 java程序员接触的第一个程序。本人使用工具为IDEA（真香定理）

• Java的注释

单行注释  //
多行注释  /*    */
javadoc注释(这种注释是专业的注释）
/**
*javadoc注释
*javadoc注释
*javadoc注释
* /

• pubilc class 和class的区别

一个java 源文件可以定义多个class
一个java 源文件当中的public的class不是必须的
一个class会定义生成一个xxx.class字节码文件
一个java源文件当中定义公开的类的话，public的class只能有一个，并且和Java的源文件名称一致。
每一个class当中都可以编写main方法。都可以设定程序的入口，想执行B.class中的main方法：java B，
要求在class文件中有main的入口：

public static void main(string[] args)

• 标识符

1、什么是标识符 

在java源程序中凡是程序员有权利自己命名的都是标识符
标识符可以标识什么元素呢？
    *类名
    *方法名
    *变量名
    *常量名
    *接口名
2.标识符的命名规则
        *只能由“数字，字母，下划线_，美元符号$”
        *不能数字开头
        *严格区分大小写
        *关键字不能做标识符
        *理论上无长度限制，但是最好不要太长
3.标识符的命名规范
        *最好见名知意
        *遵守驼峰命名方式
        *类名，接口名：首字母大写，后面每个单词的首字母大写
        *变量名，方法名：首字母小写，后面的每个单词的首字母大写
        *常量名：全部大写。

        注意:java语言源代码采用的是unicode编码方式，所以“标识符”可以用中文。

• 字面值

字面值包括：
           *整数型字面值
           *浮点型字面值
           *字符串型字面值
           *布尔型字面值（bool）

•  变量

1.什么是变量？
        -变量的本质上来说是内存中的一块空间，这块空间有“数据类型，名称，字面值（数据）
        -变量包括三部分：数据类型、名称、字面值。
        -变量是内存中存储数据的最基本的单元。
2.数据类型的作用？
        -不同的数据有不同的类型，不同的数据类型会分配不同的内存空间。
3.变量要求：变量中存储的具体的”数据“必须和”数据类型“一致、
4.声明/定义变量的语法格式：
        -数据类型 变量名；
        列如：
          *  int i;
          *  int age;
          *  int length;
5.变量声明和赋值：
        - int i=10;
6.变量赋值之后，可以重新赋值，便令的值可以变化。
7.有了变量的概念之后，内存空间得到了重复的使用。
8.访问一个变量包括两种访问的形式：
        -第一种：读取变量中保存的具体数据 get 获取
        -第二种：修改变量中保存的具体数据 set 设置

• 关于变量的分类

 局部变量
           *在方法体中声明的变量
成员变量
           *静态变量

                       在类体中加static修饰的  

           *实例变量 

                        在类体中，方法体之外 

public class Hellowrold {
        public int  id;                        //实例变量

        private String colorType;              //实例变量

        static String hello;                   //静态变量

        static final String mingzi="java";     //常量

    public static void main(String[] args) {
        int i;                                 //局部变量
    }
    
}

•  数据类型

1.数据类型的作用是？
        *程序中的数据类型的作用是指导JVM在运行的时候给该数据分配多大的内存空间。每一个数           据类型占据的内存空间的大小不同
2.java中的数据类型包括两种类型
   *基本数据类型

   *引用数据类型
         类
        接口
        数组
      ...........
3.关于基本数据类型：
        *第一类：整数型
          byte,short,int,long
        *第二类：浮点型
          float,double
        *第三类：布尔型
          bool
       *第四类：字符型
          char
4.八种数据类型各自占用的空间大小：

八种数据类型占用的字节大小

byte	1
short	2
int	4
long	8
float	4
double	8
boolean	1
char	2

 

5.字节（byte）
1 byte = 8 bit
1 kb = 1024 byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB

6.整数型当中的byte类型，占用1个字节，所以byte占用8个bit，那么byte的
取值范围是什么？
        - byte类型的最大值：（二进制）0111 1111     127
        - byte类型的最小值：（二进制）1111 1111     -128

•  关于八种基本数据类型的默认值

 数据类型              默认值
-----------------------------------------
 byte,short,int,long         0
 float,double                   0.0
 boolean                         false
 char                              \u0000
  注意：成员变量没有手动赋值系统会默认赋值【局部变量不会】

• 数据类型--整数型

1.java 中的“整数型字面值”被默认当做int类型来处理。如果要让这个“整数型字面值”当做long类型来处理的话。需要在“整数型字面值”后面添加L/l。
2.java语言当中的整数型字面值的三种表示方式：
    第一种：十进制【默认缺省的方式】
    第二种：八进制【在编写的八进制整数型字面值前面加0】
    第三种：十六进制【在编写的十六进制整数型字面值前面加0x/0X】
3.类型转化机制：    
    int i=123;   (不存在类型转换）
    long x=456;   (小容量自动转换成大容量的，成为自动转换机制）
    long y=2147483648(编译错误，过大的整数，字面值超过了整数int的范围）
    long z=2147483648L（编译正确，一开始就吧字面值当作long类型来处理，不存在类型转换）
    大容量变成小容量(而整数型的字面值赋值给byte，只要不超过byte的范围就可以，当一个整数字面值没有超出byte,short,char的取值范围，这个字面值可以直接赋值给这些变量。系统自动给加了强制类型转换）

        long x=100L

        int y=(int)x               //需要强制类型转换并且损失精度
    强制转换原理（大容量转小容量）
    原始数据：00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
    转换后数据：10000000 00000000 00000000 00000000         即将左边的二级制数据砍掉
    计算机二进制的三种表示形式：
    原码
    反码
    补码
    计算机在任何情况下底层和存储数据的时候是用的补码。

• 数据类型--浮点型

    在java中所有的浮点值字面值都是当作double类型来处理的
    要想字面值当作float来处理，需要在字面值后面加F/f。
    float     f = (float)3.0;         //存在类型转换
    float f = 3.0f;                     //不存在类型转换     初始化变量f时就指定了给一个float类型的数据

•  数据类型--布尔型

在java中boolean类型只有true和false两个值，没有其他值。
         基本数据类型之间的互相转换：转换规则
1.八种数据类型除去布尔型，其余7种都可以相互转换。
2.小容量->大容量，称为自动转换类型，基本类型的容量排序大小：
   byte<short<int<long<folat<double<char
    注：char和short可表示的种类数量相同，他两个属于平级，但是char可表示的数更大。
3.大容量->小容量，称为强制类型转换，需要加强制类型转换符。程序才能编译通过，但是在
运行的过程中会损失精度。
4.当整数字面值没有超过byte,char,short的取值范围时，可以直接赋值，可以省略强制类型转换号
5.byte,short,char混合运算的时候，计算机先转换为int类型，在进行运算。
6.多种数据类型混合运算的时候，先转换成容量最大的那种类型在进行运算。

• 运算符

*算术运算符

            +        加
            -         减
            *         乘
            /         商
            %       取余数【取模】
            ++      自加一
            --        自减一
*关系运算符

            >
            >=
            <
            <=
            ==
            !=
*逻辑运算符

            &       （逻辑与）
            |         （逻辑或）
            ！
            ^          (两边的算子都不一样就是真）
            &&     （短路与）：会出现短路现象
            ||          (短路或）
*字符串连接运算符
*三元运算符
*赋值运算符

            =
            +=
            -=
            /=
            *=

• 关于java中的“+”运算符

1、+在java 中有两个作用：
           *加法运算
           *字符串的连接运算
2、当 + 运算符两边的都是数字时做的是加法运算
3、当 + 两边中有一边是字符的话做的事字符串连接运算

• 三元运算符：

1、语法规则：    
            布尔表达式？表达式1：表达式2
2、三元运算符的原理：
            当布尔表达式的结果是true的时候选择表达式1作为表达式的结果
            当布尔表达式的结果是false的时候选择表达式2作为表达式的结果

• 控制语句

*选择结构
    -if,if..else
    -switch
*循环结构
    -for
    -while
    -do ..while()
*控制循环的语句
    -break
        *break终止的是离他最近的循环，也可以改变，需要给循环起名。
    -continue

java

•  java--方法

方法在执行的过程中，在JVM中的内存是如何分配的呢，内存是如何变化的？
    1.方法只定义不调用，是不会执行的，并且在JVM中也不会给该方法配备内存空间。
    2、在JVM内存划分的有这样三块主要的内存空间（当然还有别的）
      *方法区内存
      *堆内存
      *栈内存
    3、关于“栈”的数据结构
    *栈：stack 是一种数据机构

    *常见的数据结构
        -数组
        -队列
        -栈
        -二叉树
        -哈希表/散列表.....
    4、方法代码片段放到哪里？方法执行过程的内存往哪里分配？
 * 方法代码片段属于class字节码文件的一部分，字节码文件在类加载的时候将其放到了方法区当中。所以JVM中的三块内存，方法区最先有数据，存放了代码片段。
* 代码片段虽然在方法去内存当中只有一份，但可以重复使用，每一次调用这个方法的时候，需要给该方法分配一个内存空间，该内存空间在栈区中分配。
     5、方法在调用的时候，会给该方法分配内存空间，出现压栈动作
          方法在执行结束之后，会把该方法的内存空间释放。出现弹栈动作。
     6、局部变量在方法体中声明。局部变量在运行阶段在栈区分配。
    *方法的重载机制
        -什么条件构成了方法重载
            *在同一个类中
            *方法名相同
            *参数列表不同：1、数量不同 2、顺序不同 3、类型不同
         -方法重载和什么有关系和什么没关系？
            *和方法重载和方法名和参数列表有关系
            *方法重载和返回值类型无关
            *方法重载和修饰符列表无关

•  java-面向对象（核心）

1、面向过程和面向对象的区别
    面向过程：主要关注点是：实现的具体过程
        *优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。
        *缺点：采用面向过程的方式开发很难解决复杂的业务逻辑关系，另外面向过程的方式
        导致软件元素之间的“耦合度”非常高，只要其中一个环节出问题，整个系统就无法使用
        导致最终软件的“扩展性”差。另外，因为没有独立体的概念，所以无法达到组件复用。
   
    面向对象：主要关注点是：主要关注对象（独立体的功能）
        *优点：“耦合度”低，扩展力强。可以解决更加复杂的业务逻辑。
        *缺点：前期投入的成本高，需要进行独立体的抽取，大量的系统分析和设计。
    面向对象的三大特征：
        *封装
        *继承
        *多态
    面向对象的在软件开发的生命周期：
        *面向对象的分析：OOA
         *面向对象的设计：OOD
        *面向对象的编程：OOP

• java - 构造方法

1、当一个类中没有提供任何的构造方法，系统默认提供一个无参的构造方法这个无参的构造方法叫做（缺省构造器）。

2、当一个类中，手动的提供了构造方法，那么系统将不再提供。

3、只要没有给实例变量没有手动赋值，系统会自动给赋上默认值。

•  java - static

static :
1、static 翻译为“静态”
2、所有static关键字修饰的都是类相关的，类级别的。
3、static修饰的调用：

    *带有static 的方法调用：“类名.方法”的形式去调用，当在一个类的时候可以不用类名。
    *不带有static的方法调用：需要new一个对象，通过类创建对象去调用。
    
4、static修饰的变量为：静态变量
5、没有static修饰的变量为：实列变量

变量的声明的位置划分为：
    在方法体中：局部变量
    在方法体外，类体中：成员变量

成员变量又可分为：
    实列变量
    静态变量         
6、加static的变量叫做静态变量，静态变量在类加载时初始化，不需要new对象，静态变量的空间就开出来了。
7、静态变量的赋值是在类体当中提前赋值的。 

8、方法的划分：
    *实例方法：使用：“引用.”来访问。
    *静态方法：使用： “类名.”来访问。（也可以使用引用）
9、使用static定义静态代码块：
    语法：
        static{
        java 语句;
        }
    执行时机：
        类加载的时候，并且只执行一次。
    执行特点：
        自向而下的特点，并且在main方法之前执行。
    作用：提供一个类加载时机，当一个类加载的时候，可以做出反应。

10、java中三大变量

 

• java - this

1、this是一个关键字，全部小写。
2、一个对象一个this。
3、this是一个变量，是一个引用。this保存当前对象的内存地址，this在堆内存当中的对象的内部。
4、this可以使用在实例方法中，不能使用在静态方法中。
5、this关键字在实列方法，或者构造方法中，为了增加可读性。

为了区分局部变量和实例变量在这种情况下：this.是不能省略的。
6、this除了可以使用在实列方法中，还可以使用在构造方法中。
         语法：
         this (实际参数列表)；
         作用：
         代码复用，减少代码量。 

public class Hellowrold {
   private int i;

    public Hellowrold() {
        this(10);
    }

    public Hellowrold(int i) {
        this.i = i;
    }
}

     注意：this();的调用只能出现构造方法的第一行。 

• java - 方法覆盖

在代码级别上构成了什么方法覆盖呢？
1、两个类必须要有继承关系
2、重写之后的方法和之前的方法具有
    相同的返回值类型
    相同的方法名
    相同的形式参数列表
3、访问权限不能更低，可以更高。
4、重写之后的方法不能比之前的方法抛出更多的异常。可以更少。
注意事项：
        1、方法覆盖只是正对于方法，和属性无关。
        2、私有方法无法覆盖。
        3、构造方法无法被继承，所以无法覆盖。
        4、方法覆盖只是针对于实例方法，对于静态方法没有意义。

• Java - 封装

    java开发规范中有要求，set方法和get方法

    写一个方法专门来完成读。（get）
    写一个方法专门来完成写。（set）

    get方法的要求：
        public 返回值类型 get+属性首字母大写（无参）{
        return xxx;
        }
    set方法的要求：
        public void set+属性首字母大写（有参数）{
        xxx = yyy;
        }

封装的代码实现两步：
    第一步：属性私有化
    第二步：1个属性对外提供两个set和get方法。

• java - 继承

继承的作用：
    基本作用：子类继承父类，代码可以得到复用。
    重要作用：因为有了继承关系，才有了后期的方法覆盖和多态机制。
继承的相关特性：
    1、B类继承A类，则A类称为父类，超类，基类。B类称为子类，派生类，扩展类。
    2、java中只是支持单继承，不支持多继承。
    3、虽然不支持多继承，但是有时候会产生多继承的特点。(接口支持多继承)
    4、在继承中，除了父类的构造方法之外，全部继承下来，但是私有的属性在子类是无法直接访问的。
    5、java中的类没有显示任何类的话，则默认继承Objedt类，也就是说，一个对象与生俱来就有Object类型中的所有特征。
    6、java中继承的缺点，列如耦合度太高，修改一个类，继承的类会受到牵连。

在实际开发中，满足什么条件的时候，我们可以选择继承。凡是满足“is a”描述的，都可以继承。
   例如： Cat  is a Animal  :猫是动物     对。可以继承。

• java - 多态

多态的基础语法：
1、两个概念：
    第一个：子-->父（向上转型）(upcasting)
    第二个：父-->子（向下转型）(downcasting)
    注意：java 中允许向上转型也允许向下转型。
    无论是向下转型，还是向上转型，必须有继承关系，没有继承关系编译器报错。
2、多态指的是：
    父类型引用指向子类型对象。
    包括编译阶段和运行阶段。
    编译阶段：绑定父类的方法。
    运行阶段：动态绑定子类型对象的方法。
3、分析程序一定要分型编译阶段的静态绑定和运行阶段的动态绑定。
   如果静态绑定失败，编译阶段就不通过，更别提运行了。如果在编译阶段没有找到
   对象所在类里面的方法，编译不通过。
4、什么时候必须使用向下转型：
    当你需要访问的是，子类对象中“特有”的方法时。需要使用向下转型（强制类型转换）。
5、向下转型有没有风险：
    有时候会出现，编译阶段没问题而运行阶段异常的报错
    java.lang.ClassCastException:类型转换异常。
6、怎么避免ClassCastException异常的发生？？
    运算符：instanceof （运行阶段判断）
    一：instanceof可以在运行阶段动态判断引用指向的对象的类型
    二：instanceof的语法：  （引用 instanceof 类型）
    三：instanceof运算符的运算结果只能是：true/false
    四：c是一个引用，c变量保存了内存地址指向了堆中的对象。
            （c instanceof Cat）true 表示：c引用指向的堆内存地址中的java对象是一个Cat。
    五：养成习惯：任何时候，任何地点，对类型进行向下转型时，一定要使用
        instanceof 运算符进行判断。这样可以很好的避免ClassCastException异常。

 7、多态在开发中的作用：
    降低程序的耦合度，提高程序的扩展力。

• java - super

1、super是一个关键字，全部小写。
2、super和this的对比：
    this:
        this能出现在实例方法和构造方法中。
        this不能出现在静态方法中。
        this的语法是：this.或者this()
        this大部分是可以省略的。
        this()只能出现在构造方法的第一行，目的是通过当前的构造方法去调用本类的其他的构造方          法，目的是代码复用。
        this.什么时候不能省略呢？：在区分局部变量和实例变量的时候不能省略。
    super：
        super能出现在实例方法和构造方法中。
        super不能出现在静态方法中。
        super的语法是：super.或者super()
        super大部分是可以省略的。
        super()只能出现在构造方法的第一行，目的是通过当前的构造方法去调用本类的其他的构造          方法，目的在创建子类对象的时候先初始化父类特征。
        super.什么时候不能省略呢？：
            如果在子类个父类有同名属性，并且想要在子类中去访问父类的特征，super不能省略。

3、 super()
    表示通过子类的构造方法调用父类的构造方法。
4、结论：
    当一个构造方法的第一行：
        既没有this()又没有super()的话，默认会有一个super();
        表示通过当前子类的构造方法调用父类的无参构造方法。
        所以必须保证父类的无参构造函数方法是存在的。
5、this()和super()不能共存，且必须出现在构造方法的第一行。
6、在java语言中不管是new什么对象，最后老祖宗的Object类的构造函数
一定会执行。（Object类）的无参构造方法是处于“栈顶部”。
    栈的特点：
        最后调用，但是最先执行结束。后进先出原则。

• java - final

1、final是java语言的一个关键字。
2、final表示最终的，不可变的。
3、final可以修饰变量，方法，类。
4、final修饰的类是不可继承的。
5、final修饰的方法不可被覆盖。

6、final修饰的局部变量只允许赋一次值。

7、final修饰的表示的是最好的，不可改变的。
8、final修饰引用。引用存的内存地址是不能改变的。但是，引用指向的那个对象里面的数据可以        改变。
9、final修饰实例变量：
    系统不负责赋默认值，必须程序员手动赋值。
    这个手动赋值，在变量后面赋值可以，在构造方法里面赋值也可以。
10、final修饰的实列变量一般添加static修饰
    结论：static和final联合修饰的变量称为“常量”
        常量名建议全部大写，单词之间用下划线隔开。
    常量：实际上，常量和静态变量一样，区别在于：常量的值不能改变。
        常量和静态变量，都是存储在方法区，并且都是在类加载的时候初始化。

•  java - 抽象类

抽象类：
1、什么是抽象类？
    类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
    类本身是不存在的，所以抽象类无法创建对象，换言之，抽象类只能创建类。（无法实例化）
2、抽象类属于什么类型？
    抽象类属于引用数据类型
3、抽象类怎么定义？

    语法：
        【修饰符列表】abstract class 【类名】{
            }

4、抽象类是无法实例化的，无法创建对象。
5、final和abstract是不能联合使用的，属于对立的。
6、抽象类的子类可以是抽象类。
7、抽象类虽然无法实例化，但是具有构造函数，供子类使用的。
8、抽象类关联到一个概念：抽象方法：
    抽象方法表示没有实现的方法，没有方法体的方法。
        例如：  pubic abstract void doSome（）;
    抽象方法的特点：
        第一：没有方法体，以分号结尾；
        第二：前面修饰符列表中有abstract关键字修饰。
9、抽象类中不一定有抽象方法，但抽象方法一定在抽象类中。
10、非抽象类继承抽象类，必须把抽象类中的抽象方法实现！！！。

11、面向抽象编程：通过向上转型，实现多态。

•  java - 接口

1、接口也是一种“引用数据类型”。编译之后也是一个class字节码文件。
2、接口是完全抽象的。
3、接口的语法：

    【修饰符列表】interface 接口名{ 

                                }

4、接口可以继承，并且可以多继承。一个接口可以继承多个接口。
5、接口只包含两部分内容：
            常量
            抽象方法：（因为接口里面的方法都是抽象方法，所以方法是没有方法体的。）
6.   接口中所有的元素都是public（公开的）
7、接口在定义方法时：public abstract修饰符是可以省略的。
8、接口在定义常量时：public static final 是可以省略的。

9、 类和类之间叫做继承，类和接口之间叫做实现。
10、继承之间用关键字：extends
        实现之间用关键字：implements
11、当一个非抽象的类去实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖，重写）。
12、一个类可以同时实现多个接口。
13、在一个类中，继承和接口都存在的话：
         语法：extends  关键字在前。
          implements  关键字在后。

例如：class Cat extends Animal implements Flyable{

               }

        注意：若是一个类没有继承的话，默认继承Object类。
14、使用接口，写代码的时候，可以使用多态。

抽象类和接口有什么区别

    在语法上的区别：
        抽象类是半抽象的。
        接口时完全抽象的。

        抽象类有构造方法。
        接口没有构造方法。

        类与类之间时单继承。
        接口和接口之间支持多继承。
        一个类可以实现多个接口。
        一个类只能继承一个抽象类。

• java - 数组

1、java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父亲是Object。
2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）
      数组：字面意思是“一组数据”
3、数组当中可以存储“基本数据类型”，也可以存储“引用数据类型”。
4、数组是引用数据类型，所以数组对象是堆内存当中。（数组是存储在对当中的）
5、数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”
6、数组一旦创建，在java中规定，长度不可变。
7、数组的分类：一维数组，二维数组，三维数组，多维数组.....
8、所有的数组对象都有 length属性。用来获取数组中元素的个数。
9、java中的数组要求数组元素的类型统一。
10、数组每一个元素是有下标的{0，1，2，3.....length-1}
11、数组在内存方面存储的时候，数组中的元素内存地址是连续的。
12、所有数组都是拿“第一个内存地址”作为整个数组对象的内存地址。

13、数组这种数据结构的优点和缺点：
        优点：查询/查找/检索某个下标上的元素时效率极高。可以说时查询效率最高的一个数据构。

        因为？
        第一：每一个元素的内存地址在空间存储上是连续的。
        第二：每一个元素类型相同。
        第三：知道第一个元素的内存地址，知道每一个元素占用的空间大小，又知道下标，所以
              可以通过一个数学表达式就可以计算出某个下标上的元素的内存地址。直接通过内存地址
              访问元素，所以数组的检索效率时最高的。
        

        比如： 

---

        数组中存储100个元素，或者存储100万个元素，在元素查询方面，效率时一样的。因为数组中元素在
        查询时，不会一个一个找，是通过数学表达式计算出来内存地址，通过内存地址来进行访问的。

---

    缺点：
        第一：由于为了保证数组中每一个元素的内存地址连续，所以数组上随即删除或者随机增加元素的时候，效率较低，因为随机增删元素会出现后面元素整体统一向前或者向后的操作。
        第二：数组不能存储大容量，为什么？
            因为很难在内存空间找到一块特别大的连续的内存空间。
一维数组的静态初始化和动态初始化：

    静态初始化：
        int[] arr ={1,3,4,5};

     动态初始化：
        Object[] objs = {new Object(),new Object()};

一维数组的遍历：

public class Hellowrold {
    public static void main(String[] args) {
        int[] arr = new int[5];
        for(int i = 0;i <arr.length;i++){
            System.out.println(arr[i]);
        }
    }   
}

• java - Object

Ojbect中需要知道的方法：

    protected Object clone()      //负责对象克隆的
    int hashCode()                    //获取对象哈希值的一个方法
    boolean equals(Object obj) //判断两个对象是否相等
    String toString()                  //将对象转换成字符串形式
    protected void finalize()      //垃圾回收器负责调用的方法
    toString()方法：
    代码：
    public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        默认实现：
    类名@对象的内存地址转换为十六进制的形式。

    注意：toString（）方法在创建子类的时候，一般是要重写的。为了让toString()方法输出，你想      要的，简洁的结果。

equals方法：
1、    源代码：
     public boolean equals(Object obj) {
               return (this == obj);
    }
    以上方法是Object的默认实现。

注意：以后的编程中，都要通过equals方法来判断两个对象是否相等。
Object类给的这个默认的equals方法显然是不够用的。判断两个对象是否相等的时候，不能使        用“==”，因为“==”比较的是两个对象的内存地址。在设计子类的时候，需要对equals方法进行重写。

java中基本数据类型比较相等，使用==
            java中引用数据类型统一使用equals方法来判断是否相等。
注意：重写equals方法要重写到底。
 

hashCode()方法：
源代码：     public native int hashCode();
    提示：这个方法不是抽象方法，带有native关键字,底层调用c++。
输出结果：hashCode()方法返回的是哈希码：实际上就是一个java对象的内存地址，经过哈希算法，得出的结果。

 

•    java -- String

1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。

2、在java中随便使用双括号括起来的都是String对象。例如："aba"

3、在java中规定，双引号括起来的字符串，是不可变的，也就是说“abv”从出生到死亡，不可变。

4、在JDK中双引号括起来的字符串，都是直接存储在“方法区”的“字符串常量池”当中的。（当new对象创建的时候，也是如此）

       关于String类中的构造方法：（了解即可，使用时翻API帮助文档）

常用的构造方法：

           

1、        String()  

2、        String(byte[] bytes)

3、        String(byte[] bytes, int offset, int length) 

4、        String(char[] value)

5、        String(char[] value, int offset, int count)

String类中的方法：

char         charAt(int index) 

返回 char指定索引处的值。

 int                   compareTo(String anotherString)

按字典顺序比较两个字符串。

boolean         contains(CharSequence s) 

当且仅当此字符串包含指定的char值序列时才返回true。

boolean         endsWith(String suffix) 

测试此字符串是否以指定的后缀结尾。

boolean         equals(Object anObject) 

将此字符串与指定对象进行比较。

boolean         equalsIgnoreCase(String anotherString)

将此 String与其他 String比较，忽略大小写。

 byte[]             getBytes()

使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。  

 int                 indexOf(String str)

返回指定子字符串第一次出现的字符串内的索引。

boolean         isEmpty()

判断字符串是否为空字符串（不是null）

 int           lastIndexOf(int ch, int fromIndex)

返回指定字符的最后一次出现的字符串中的索引，从指定的索引开始向后搜索。 

int                 length()

返回此字符串的长度。

String           replace(CharSequence target, CharSequence replacement)

将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。 

String[]         split(String regex)

将此字符串分割为给定的 regular expression的匹配。 

boolean         startsWith(String prefix)

测试此字符串是否以指定的前缀开头。

String            substring(int beginIndex)

返回一个字符串，该字符串是此字符串的子字符串。  

 String             substring(int beginIndex, int endIndex)

返回一个字符串，该字符串是此字符串的子字符串。

char[]             toCharArray() 

将此字符串转换为新的字符数组。

String            toLowerCase()

将所有在此字符 String使用默认语言环境的规则，以小写。   

String            toUpperCase()

将所有在此字符 String使用默认语言环境的规则大写。 

String            toString() 

此对象（已经是字符串！）本身已被返回。

String            trim()

返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。 

 static             String valueOf(多个重载) 

返回String字符串形式。

 声明：以上是我在学习java中记的笔记。学习过程来源于B站。如有错误，欢迎大佬来告知，小弟感激不已!!!!!!