java基础知识

Posted 2020-11-22 夜半情深

一、杂货

1、逻辑运算符的区别与作用

逻辑运算符	作用
&	与作用，左右两边两个判断结果都为true就是true，否则是false
|	或左右，左右两边两个判断结果只要有一边为true，结果就是true，否则就是false
^	异或，你为true我就是false
&&	左右两边，左边如果为false，右边不执行，直接返回结果false
||	同理：左边如果为true，右边不执行直接返回true

2、判断过程中：出现了问题，当前的问题就是我们在判断中内容输入的都是正确的，结果还是为false

         分析：因为我们原来使用==判断是判断的基本数据类型。如果换成引用数据类型了，我们在方法中引用的其实是对象的地址值。如果使用的是==判断对象的话，那么判断的就是对象的地址值。

 

         解决办法：在Java中 ，判断基本数据类型的值，使用的是==。但是判断对象的值使用的就是equals，将具体的值放入小括号中，通过hashCode生成进行判断。

3、位移总结：

         左位移：会将正数移动成负数。一位数据二进制是从右往左位移，会触碰二进制的符号位。

    右位移：不会再符号位补数据，负数还是1，正数还是0。所以我们操作右位移的时候，数据正负不会变。

    无符号右位移：可以将负数移动成正数，但是正数不会移动成负数，因为右位移，补的是0，不会补1。

   4.基本数据类型

①、能否拼接？

                   不能做拼接，基本数据类型，进行拼接，就相当于是加法运算，将内容进行编号相加。

 

 

         ②、后期我们还会学习引用数据类型

                   1、如何区分引用数据类型和基本数据类型：基本数据类型，是定义类型的工作，没有对应的方法也没有对应的操作，只能定义类型和赋值存储类型。

                   2、当前基本数据类型格式是全小写命名，引用数据类型是首字母大写，其余小写命名格式。

 

         ③、运算过程中我们会设计到类型转换。

                   高类型转换成低类型：强制类型转换，如果不使用强制类型转换，Java默认是不让你转换的。

                   低类型转换成高类型：自动类型转换。Java默认就采取的是自动类型转换。

                   为什么字符类型在相加的时候，使用的是数字。因为字符默认大小没有int高，在加法操作的时候，默认就转换成了int类型。

         注意：如果是强制类型转换，就会损失精度，和你想要的数据，相差比较大。这也是为什么Java默认不使用强制类型转换的原因，因为损失精度，影响结果。

 

5、字符类型

数据类型	字节数	二进制位数
byte	1	8
short	2	16
int	4	32
long	8	64
float	4	32
double	8	64
char	2	16
boolean	1	1

boolean类型的值只有true和false两种逻辑值，在编译后会使用1和0来表示，这两个数在内存中按位算，仅需1位（bit）即可存储，位是计算机最小的存储单位。

6、简单运算：+ - *

         大家在操作的时候，需要注意一个小细节，容器不同的情况下，整数类型，会默认自动转换成int类型。

7、如果当前的属性，没有赋值，请问是什么值？

                   String类型默认值是：null

                   Int类型默认值是：0

 

二、Java关键字

1、引用数据类型，String类：字符串类型，我们如果设置的是字符串，也就是带有双引号（所有的数据都要””）的内容，就需要用到容器：String

2、  随机数对象：Random（使用时需要导包）

3、当前Scanner输入对象，对输入的信息非常严格

整数类型：只能输入整数，输入其他的数据就会报错。

小数类型：可以输入整数，也可以输入小数。

字符串类型：输入啥都可以拿到，可以输入数字，可以输入小数，也可以输入字母。

    4、创建出当前的对象，创建对象，我们需要提供一个关键字：new

操作对象我们需要注意：对象类型首字母必须大写，格式问题。

                   格式：对象类型 容器名称 = new 对象类型（）；

5、提示补全：CTRL+1（数字）

6、封装四个关键字使用的范围

位置	private	默认的	protected	public
同一个类	是	是	是	是
同一个包内的类	否	是	是	是
不同包内的子类	否	否	是	是
不同包并且不是子类	否	否	否	是

         注意：当前属性如果需要完全给别人使用，我们就需要设置公共的：public

         注意：当前属性如果只能自己完成，别人不能使用，我们就需要设置私有的：private

 

         注意：private 使用：方法：get方法与set方法，可以被别人使用。

 

7、在子类对象中，通过关键字：extends，定义继承关系

 

三、快捷键

    1、查看源码的方法：

         按着键盘中的：ctrl按键不动,点击对象的引用名称，也就是首字母大写的那个对象左键。进入后对象文件名为xxx.class就是源码。

2、快速查询方法：ctrl + o

3、删除整行：CTRL+D

4、设置自动补全：WindowàPerferencesàJavaàEditoràContent Assist

 

不要删除小点，直接添加：qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM

5、快捷键生成：alt + shift + s（快速生成get,set方法，构造方法）

                   如果不会用快捷键：source中也可以找到，在左上角菜单中。

快捷键生成有参与空参：alt + shift + s

 

 

 

四、异常

 

1、by zero（零不能做除数）

2、索引角标越界异常（一般出现在数组中）

3、空指针异常（一般非法使用NULL）

五、方法和帮助工具类

1、length：动态获取数组长度，长度从1开始计数。

2、数组帮助工具类：Arrays，是在当前的util包中，只要看见了util包，我们就可以判断当前是一个工具类。

         例如：数组排序

　　  arrays.sort();

六、算法

1、冒泡排序算法

        //冒泡排序

for(int i = 0; i < arr01.length; i++) {
for(int j = 0; j < arr01.length - i - 1; j++) {
if(arr01[j] > arr01[j + 1]) {
temp = arr01[j];
arr01[j] = arr01[j + 1];
arr01[j + 1] = temp;
}
}
2、选择排序算法

//选择排序
for(int i = 0; i < arr01.length; i++) {
for(int j = i + 1; j < arr01.length; j++) {
if(arr01[i] > arr01[j]) {
temp = arr01[i];
arr01[i] = arr01[j];
arr01[j] = temp;
}
}
}

       

 

七、数组

1、数组能否存储多种类型在数组中：数组在Java中是可以存储不同类型的数据的，但是得需要创建数组的时候，将创建的类型，变成对象类型。而当前对象的类型必须是：Object

2、什么是Object：当前Object是Java中的所有对象的爹！不管是String还是后期的其他引用数据类型，都是通过它来创造的，所以当前要想在数组中存储不同类型的值，我们就需要使用Object

3、具体使用

 

 

1、  后期在面试中如果被问道了

1、  数组是不允许存储不同类型的元素的，必须得严格按照创建数组中类型的具体定义来 添加内容。

2、  如果当前真的需要存储不同类型的数据在数组中，我们其实可以通过Object定义存储。

3、  说白了，在Java中，部分的解释不是绝对的。通过数组我们得到了启发，可以通过万能对象的创建进行存储。

5、数组创建后不能修改长度，也就意味着创建后不能增加新的容器长度，也不能删除容器长度。

         数组创建后，不能增加也不能删除。

6、如果需要去重，我们需要创建新的数组进行存储。

八、面向对象

      1、面向对象最基本的操作：

1、  如何创建对象：通过class对象，创建类名

2、如何设置属性以及属性的作用：属性是对象内的参数，我们可以动态设置参数变量。

3、如何设置对象中的方法：对象中的方法，就是给别人调用使用的。方法有返回值和方法没有返回值的区别。通过关键字，void和其他的返回类型定义。

4、方法中小括号的作用：小括号的作用就是参数的传递，我们方法中小括号内的参数一般命名为：形参。形参中，可以定义多个参数，参数与参数间使用逗号相隔。

      2、封装其实就是对对象进行封装工作

                   1、封装属性：对属性的访问权限进行了封装，私有的只能自己用，公共的谁都可以用。

 

                   2、封装方法：普通方法也可以使用关键字进行封装，效果一样，私有的方法别人不能用。

 

                   3、对私有的属性，可以封装一套获取方法和设置方法，分别是set和get

                            Set别人设置我当前的私有属性的数据。

                            Get别人获取使用我当前的私有属性的数据。

 

                   4、对创建对象的时候进行封装：构造方法

                            创建对象的过程中，我需要创建出来的对象是空对象，那么就用空参构造方法。

                            创建对象的过程中，我需要创建出来的对象是带有数据的对象，不是一个空对象，那么我们就使用有参构造方法来创建。

 

                            如果对象中不写构造方法，默认就有空参，如果写了那么就使用写了的，如果只写有参不写空参，那么就无法使用空参创建对象。默认的空参在你写了有参的时候就会消失，需要手动在再写空参才能正常使用。

 

                   5、构造方法和普通方法一样，可以方法名相同，但是参数数据类型与数量不能相同，必须在同一个对象中，我们称之为是方法的重载。

                            重载：方法名必须相同，参数类型不同。

                            重载：可以修改方法的访问修饰符，可以修改返回类型，无返回还是有返回。

      3、输出对象名称显示地址

         1、当前我们输出对象的名称，显示的是地址值，出现的原因在于当前我们打印出了对象的HashCode值

 

 

         2、解决办法如何完成：我们需要在对应的对象内，设置输出格式才能解决，需要通过方法：toString完成（进入Student对象中，设置toString方法）

 

 

 

2、  toString方法，我们依然可以通过快捷键生成：alt + shift + s

 

 

3、继承

1、重写

1、方法的重写，就是对父类的方法进行升级，如果子类和父类都有相同方法的时候，默认就会调用子类的重写方法。

 

         重写方法，为什么上面要有一个：@Override：其实是注解，帮助我们检测当前的方法，是否是重写方法，如果不是，那么就报错。

Override注解的功能：说白了，就是帮助我们检查方法是否是重写方法，如果不是就报错，其实我们也可以删除当前的注解，删除后就没有检查功能了。

 

方法的重写，需要注意事项：

                   1、方法名必须相同。

                   2、必须是继承或者实现关系。

                   3、重写方法传递的形参必须与父类的方法保持一致，不能设置其他形参。

                  

 

                   4、重写的方法，访问权限封装关键字：子类的访问权限可以修改，但是权限的大小一定要比父类大。不能比父类小。

                   父类是：受保护的，子类可以使用：受保护的和公共的。不能使用默认的，和私有的。

                   5、父类和子类重写方法的返回值，要保持一致。

 

         2、继承：在Java中是单继承。可以多重继承，父类可以有多个儿子，但是儿子只能有1个爹。

2、面向对象：继承，使用构造方法

         1、有一种情况：父类抽取共性，子类还有自己的特性，我们可以在创建子类的时候，将数据设置到父类中

                   方法一：使用this关键字，调用父类的方法进行设置。

 

 

                   方法二：使用super关键字，调用父类的构造方法存储。

 

 

1、  super关键字

1、  在构造方法中，引用super就是去到父类的对应构造方法中。

 

2、  在普通方法中，引用super，那么就是父类对象的引用。

 

3、  区分：看super调用的时候是否带有小括号。

Super带有小括号：引用构造方法。

 

 

Super不带小括号：父类对象的引用。

 

 

         3、父类对象如何没有继承，那么能否使用super，是可以使用super关键字的。

 

 

         4、父类如果没有继承，super引用引用到哪去了呢？

                   父类如果没有继承，默认都是指向的Object对象

        

3、final关键字的使用

         1、final关键字：最终的，不可更改的。

 

         2、具体使用：（面试原题）

                   1、final可以修饰对象：但是修饰后，当前的对象是不能够被继承的。

 

 

                   2、final可以修饰属性：但是修饰后，属性就会变成常量，不能够修改。

 

 

                   3、final可以修饰方法，但是修饰后，方法不能够被重写。

 

 

         3、final的作用是什么

                   1、每个用户都会存在一个用户id，这个属性后期任何人都不能修改，所以用户的属性我们后期要设置final变成常量。

 

                   2、方法呢：有些重要的方法，比如支付方法和退款方法，我们是不允许随便修改的，所以我们当前支付的方法，是不允许重写的。只要和钱打交道的方法，我们都需要严谨对待。

 

                   3、对象，有些对象是不允许被继承的，如果一旦继承了，那么当前对象里面的方法以及操作，我不需要任何的判断和权限，就能够直接使用了。如果是特殊对象，和高加密对象等等，我们是不允许他被继承的。

 

         4、后期大家遇见面试题问final，和笔试题问答题final。我们就需要如下回答

                   1、属性使用final：变常量，让用户权限等数据，变成不可修改的数据。

 

                   2、方法使用final：敏感操作的方法，一般情况下是不予许被重写的，那么我们就需要在方法上使用final。

 

                   3、对象使用final：项目的核心对象，敏感对象，一般情况下都是不需要继承的，一旦继承，里面的所有非私有的方法和属性都能够直接被调用，。非常不安全。我们需要将对象设置为final修饰的，这样对象就不能直接被继承了。

4、static关键字的使用

         1、static是什么：static是静态的意思，它的主要作用就是让程序的生命周期拉长，让属性可以不通过new关键字创建就能直接使用。让方法能够不通过关键字就可以直接调用。

 

         2、static修饰的属性和方法，我们可以不通过new对象，通过对应的类名直接调用

 

                   测试类：

 

 

         3、原理：当前对象如果设置了static修饰的关键字，那么对象在new之前，静态的属性和方法，其实就已经加载到了内存中，加载是通过.class文件生成的时候就加载进入了。

 

 

         4、static修饰的优点：访问的权限比较大，可以不通过new关键字创建对象就能直接使用了。而且数据，访问的权限是全局的。

                   多个方法之间可以共享数据，但是不能再多个程序中共享。

                   成员变量，如果使用static，那么多个方法之间，拿到的数据就是共享的。

                   方法也是同理。

 

         方便对象的使用，快捷。减少new的使用。

 

         5、static修饰的缺点：

                   1、共享的数据，有一个方法进行修改了，其他的方法拿到的数据都是修改后的。

 

                   2、共享的数据，声明周期又长。也就意味着内存回收周期就长，长期使用比较占用内存。

 

         6、静态代码块使用：我们对象在创建前就会直接调用

 

 

         7、查看谁先调用

 

 

         8、静态代码块不管是在上面还是下面，都会先构造方法执行，原因就是静态.class文件的时候就已经在了，准备执行了。而构造方法是new关键字运行的时候才会调用。

 

         9、在当前的程序工作空间中，bin文件夹里面都是class文件，但是需要注意，程序中的代码，一旦出现错误，class文件就会自动删除。没有错误的情况下后，文件又会自动生成。