2020-06-25java基础整理

                                                                                                                                                                                                                                                                                                                                                                            java基础整理

java环境搭建
首先就是jdk和jre的关系
Jdk包含jre,jre包含jvm和java运行环境，如果开发程序的，就用ldk,要是光运行class文件，就用jre
安装jdk设置路径，里面是有jre的也设置路径
安装好之后一定要在命令行里面去测试是否是安装成功的：到bin目录下写javac 回车有东西就是成功的
其次就是基本的Linux的常用命令
tab：就是补全你写的名字
cd 文件夹名称：进入下一个文件夹
cd…：返回到上一个文件夹
cd\：退回到盘符根目录下
cd 文件的全名：就是D盘里面的234还是需要切换盘符的
dir：显示的是目录
cls：清除屏幕
d：：就是进入d盘
ipconfig：这是java里面的ip环境
向上的箭头：就是调出之前打进去的内容
复制/粘贴：右键标记然后是enter 然后是右键粘贴

   命令行打开方式:1.开始，下面的框框里写入cmd然后enter
                   2.win+r    cmd    enter
   java是跨平台的，但是c++不是跨平台的，其中java的跨平台指的是没个操作系统都是有java的jvm ，但是jvm不是跨平台的        
       命令行里面去运行java文件：（在电脑里去配置好jdk的路径【我的电脑右键属性高级环境变量在用户变量里面去设置JAVA_HOME在系统变量去用百分号设置JAVA_HOME然后用分号分开】）来到java文件的位置，javac 文件名.java    然后java  文件名
    记得编辑的java文件要选择是全名：工具  文件夹选项 查看 隐藏文件扩展的名去掉
    注释：//单行注释
    		/**/多行注释
    		/**  */文档注释
    标识符：自己定义的内容  规则：
    						组成字母A-Z a-z（52个）数字0-9 _          			$ 
    						注意：不能是数字开头 不能是关键字
    						类的名字：首字母大写，第二个单词首字母大写
    						方法的名字：首字母小写，每个单词首字母大写

程序=数据+逻辑

数据类型：基本数据类型（整数【byte（一个字节 -128-127）short（2个字节 ）int（4个字节）long（8个字节）】，小数【float（4个字节）double（8个字节）】，字符【char（2个字节）】，布尔【boolean（1个字节）】）引用数据类型（数组，类，接口）
数据类型转换：范围小的自动转换范围大的，范围大的强制转换成范围小的，但是可能会数据丢失（溢出）

计算机存储单元：硬盘是永久存储，内存是临时存储（运行的时候用到，不运行就会清除掉）计算机最小信息单元叫bit（位）b表示 最小的存储单元是字节（byte）B表示 （8个bit表示一个byte表示一个数据 其他的进制都是1024 KB MB GB TB PB）
引用数据类型：Scanner类作用：就是让我们在命令行中接收键盘的输入，
使用步骤：
1，导入包，2，创建scanner类的对象（Scanner sc=new Scnner（System.in）），3，对象调用方法sc.nextInt()//接收键盘的输入，保证输入的是整数 next()接收键盘输入的字符串数据
Random类（随机数）：用于产生随机数 nextInt(int maxValue) 产生【0-maxVlue）
nextDouble()产生【0.0-1.0）的类
三元运算符：判断条件？表达式1：表达式2
break：在循环中终止循环作用 全都结束
continue：在循环中终止本次循环，开始下一次循环

switch里面表达式的数据类型要求是：byte short int char enum，String
switch特性：case穿透性（就是如果没有break，如果有匹配就会一直穿透下去）
数组的定义：int[] x=new int[100]
int[] arr=new int[]{元素1，元素2，元素3}（其中里面[]是不能写任何内容，写了编译失败）
int[] arr={元素1，元素2，元素3}
循环：while不确定循环次数
for，知道循环次数，计数器思想
数组的遍历：for(int i=0;i<arr.length;i++){
syso(arr[i]);
}
数组中的俩个常见的异常：
索引的越界异常，
空指针异常
arr=null就是arr不再保存数组的地址了，这样就会产生空指针异常
二维数组的定义：int [][]arr=new int [3][2];
或者是int[][] arr={{2,2},{3,3},{3}}

   jvm对自己的内存进行了划分五个区域：
   寄存器：内存和CPU之间
   本地方法栈：JVM调用了系统中的功能
   方法和数据共享：运行时期class文件进入的地方
   方法栈：所有的方法运行的时候进入的内存
   堆：存储的是容器和对象
   （这里所有的开空间和清空间jvm就会处理的，但是c++开空间不用管，但是清空间需要管）
   数组的最小索引是0 最大索引是数组.length-1
   方法重载的特性（overload）：在同一个类中，允许出现同名的方法，只要方法的参数列表不同即可，这就是方法重载，
   参数列表不同：参数的个数，数据类型，顺序
   方法重载的注意事项：
       1,参数列表必须不同，
       2，重载和参数变量名无关
       3，重载和返回值类``型无关
       4，重载和修饰符无关
       技巧：重载只看重的是方法名和参数列表

ArrayList集合的使用
    也是引用数据类型：
    步骤：
         1，导入包，
         2，创建引用类型的变
              数据类型<集合存储的数据类型>变量名=new 数据类型<集合存储的数据类型>();
              集合存储的数据类型：要将数据存储在集合的容器中
              创建集合引用变量的时候，必须要指定好，存储的类型是什么
         3，变量名.方法
  注意：集合不存储基本类型，集合只存储引用类型（基本数据类型变到引用数据类型除了int是Intager和char是character，其他的都是将首字母变成大写）
  ArrayList 集合中的方法：
        add(参数)  向集合中添加元素，数据存储进去
        方法中的参数类型它和你定义集合对象时候是一致的
        eg：ArrayList<Integer> array=new ArrayList<Integer>();
             array.add(3);
        get(int index)   取出集合中的元素，get方法中的参数中写索引  
        size()   返回集合的长度，就是集合存储元素的个数

集合的遍历
也是索引思想
集合的索引是从0开始，到size（）-1
方法get（int index）

ArrayList方法补充：
   add（int索引，存储的元素）将元素添加到指定的索引上
   set（int 索引，修改后的元素）将指定索引的元素进行修改
   remove（int 索引）删除指定索引上的元素
   clear()清空集合中的所有元素
   

计算求奇数的和
方法一：for（int i=0；i<100;i++）{
		if(i/2==1){
		sum+=i;
		}
}
方法二：for(int i=1;i<100;i+2){
	sum+=i;
}
计算水仙花数
for(i=100;i<1000;i++){
	ge=i%10;
	shi=i/10%10;
	bai=i/100;
	if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
		syso(i);
	}
}

ASCII编码表
人为规定	，字母az对应的十进制数97-122，大写字母AZ对应的十进制数65-90，数字0-9对应的是十进制是48-57 
GBK简体中文码表
国际标准ISO
	char类型转换成int类型
	char  俩个字节  int 四个字节
	char类型转换成int类型的时候，类型自动提升，char类型会查询编码表得到整数
	int类型转换成char类型的时候，强制转换会查询编码表
	char存储的是汉字，查询Unicode编码表（一个汉字在Unicode里面是占有俩个字节的）
	char类型可以和int的类型计算，提升为int类型，内存中占有俩个字节
	char的取值范围是0-65535 short类型的取值是-32768-32767
		shor类型的最高位是符号位，1是负数，0是正数，后面所有的字节都是数值位，
		char类型的二进制全是数值位，没有符号位，它里面存储的数值都是正数，不能是负数，是无符号的数据类型
		
		  

九九乘法表

打印数组元素

数组的反向遍历：

数组的逆序：数组中的元素进行位置上的交换（就是数组中最远的俩个索引，进行位置交换，实现数组的逆序，使用的是数组的指针思想，就是变量，可以随时变换索引）
实现步骤：
1，定时方法，实现数组的逆序，
2，遍历数组，
就是使用的指针思想，就是最远的索引和最小的索引进行变换位置，到最小的和最远的相等的时候就不会再更换
使用的 是第三放变量

 数组的排序：一般都是升序排列，元素，从小到大的排列
   俩种排序的方式：
          选择排序：数组的每个元素都进行比较
          冒泡排序：数组中相邻元素进行比较
          规则：比较大小，位置交换
          实现数组的选择排序：
          	返回值：没有
          	参数：数组
          	实现步骤：
          	   1，嵌套循环实现排序
          	      外循环，控制是一共比较了多少次，
          	      内循环，控制的是每次比较了多少个元素
          	   2，判断元素的大小值
          	     小值存储到小的索引
 

冒泡排序：思想就是都是相邻的数组去比较，而且每一次比较完之后，最大值都会放到最后面，然后剩下的在进行比较。

折半查找法：思想就是最小的索引和最大的索引求和取平均数然后再赋值给中间索引，如果被查找的数（key）比中间的数大那么就是将中间索引+1赋值给最小索引，如果被查找的数比中间的数小，那么就是将中间索引-1赋值给最大索引，如果min>max查找就结束了，（前提是有序的而且岁升序的）

面向对象

面向对象思维方式的好处：
    1，面向对象思维方式是一种更符合人们思考习惯的思想
    2，面向过程思维中更多的体现的是执行者（自己做事情），面向对象更多的是体现的是指挥者（指挥对象做事情）
    3，面向对象做事情，将复杂的问题简单化。
局部变量和成员变量的区别：
    1，定义位置的区别：
        成员变量定义在类中方法外，
        局部变量方法内，语句内
    2，作用域不同
        成员变量，作用范围是整个类，
        局部变量，方法内，语句内
    3，默认值不同
        成员变量有自己的默认值，
        局部变量，没有默认值，不赋值不能使用
    4，内存位置不同
       成员变量，跟随对象进入堆内存中存储，
       局部变量跟随自己的方法进入栈内存
    5，生命周期不同，
      成员变量，跟随对象，在堆中存储，内存等待jvm清理 生命周期相对较长
      局部变量，跟随方法，方法出栈，生命周期相对较短

封装的表现:
		1,方法就是一个基本的封装体，
		2，类其实也是一个封装体
封装的好处：
		1，提高了代码的复用性，
		2，隐藏了实现细节，还要对外提供访问的方式，便于调用者使用，这是核心之一，也可以理解为这就是封装的概念
		3，提高到了安全性

get和set方法
	一般对于属性的操作，赋值叫set，取值叫get，因此对于私有的变量访问的方式可以提供对应的setXxx或者是getXxx的方法
总结：
 	类中不需要对外提供的内容都私有化，包括属性和方法，以后再描述方法属性都是要私有化的，并提供get set方法对齐进行访问
 	注意：私有仅仅是封装体现的形式而已
 	

this关键字
	区分成员变量和局部变量的同名问题
	如果你想要在方法中访问成员变量，写this.（其实实际上就是将对象名所代表的的地址给了this，而对象名所代表的地址又是指向堆内存的）
	如果方法里面的局部变量和类里面的成员变量重名，对象调用方法的时候就会调用方法里面的局部变量，会就近访问原则的去调用。（就是方法里面自己有的话就直接调用方法里面的，要是没有的话就会调用成员变量里面的）	

继承
	格式：
	Class 子类 extends 父类{}
	子类自动拥有父类中可以继承的属性和方法
	子类中可以直接调用父类中的成员
	
继承的好处：
	1，继承提高了代码的复用性（就是父类的功能可以吹让子类直接拿来用），提高了软件开发效率
	2，继承让类与类之间产生了关系，提供的多态的前提
注意事项：
	1，在java中类只允许单继承，不允许多继承，也就是说一个类只能有一个直接父类（会产生安全问题）但是支持多层继承，同时可以拥有其他的类的属性和方法
	2，多个类可以继承一个父类，
	3，支持多层继承（一个父类可以再去继承另外的父类）
继承后，子父类成员变量的特点：
	子类的对象调用成员变量
		子类自己有，就会调用子类自己的
		子类没有，就会调用父类的
		注：如果调用子类成员的就是写this.（调用自己本类成员）
			如果调用的是父类的就写super.（调用自己父类成员）
			

重写（覆盖override）
	子类中出现了和父类中一模一样的方法的时候子类重写父类的方法
	需求：就是子类需要父类的功能时，而功能主体子类又有自己特有的方法时，	
注意事项：
	子类方法覆盖父类的方法，必须保证权限大于或者等于父类中的权限。
	必须一模一样（函数的返回值类型，函数名，参数列表）
	

抽象类
	就是对子类的共性抽取，然后形成的父类只有这个功能，但是没有具体的方法
	格式：
		public abstract class Develop{
			pubic abstract void work（）；
		}
抽象类是不能实例化对象，不能new的
抽象类的使用：定义类继承抽象类，将修饰方法重写，创建子类对象
抽象类的特点：
	1，抽象类和抽象方法都需要被abstract修饰，抽象方法一定要定义在的抽象类中
	2，抽象类不可以直接创建对象，原因：调用抽象方法没有意义
	3，只有覆盖是抽象类中的所有的抽象方法后，其子类才可以创建对象，否则该子类还是一个抽象类。
	抽象类的细节问题：
		1，抽象类一定是一个父类？
			是的，因为不断抽取而来的
		2，抽象类中是否可以不定义抽象方法？
			是可以的（可以不定义抽象方法，但是可以定义带有方法体的方法，让子类继承以后可以直接使用），那这个抽象类存在的是什么意义呢？仅仅是不让该类创建对象，可以直接让子类使用（我的理解：那么也就是说抽象类里面又可以写方法体，又可以写抽象方法，那么他就是包含了父类的功能，也就是说，我们可以直接去创建抽象类作为父类，也就是说大部分父类都是抽象类）
		3，抽象类关键字abstract不可以和那些关键字共存：
			1，private：私有的方法子类是无法继承的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract就要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法，互相矛盾。
			2，final
			3，static

接口
 	接口只是描述所应该具备的方法，并没有具体的实现（就是接口里面全是抽象的方法）具体的实现是由接口的实现类（相当于接口的子类来完成）。这样的功能定义与实现分离优化了程序的设计
 	记住：一切事物均有接口，即一切事物均有接口
定义格式：
public interface 接口名{
	抽象方法1；
	抽象方法2；
	…………
}
注意：
	1，接口中的方法均为公共访问的抽象方法
	2，接口中无法定义普通的成员变量
类实现接口
	格式：class 类 implements 接口{
		重写接口中的方法
	}
接口中成员变量的特点
	1，接口中可以定义变量，但是变量必须有固定的修饰符修饰，pubic static final所以接口中的变量也称之为常量，其值不能改变（常量被static修饰，可以被类名直接调用，被接口的名字直接调用，其中public static final修饰符，在接口的定义中可以省略不写，但是不写不等于没有，三个修饰符还可以选择性书写）
	2，接口中可以定义方法，方法也有固定的修饰符：pubic abstract 返回值类型 方法名（参数列表）
			其中修饰符public abstract可以写，也可以不写，但是写不写都有
	3，接口中不可以创建对象
	4，子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化，否则子类就是一个抽象类
接口的多实现
	接口的多实现没有安全隐患的问题，因为接口里面的方法是抽象的，没有方法体，实现的时候需要子类重写才可以。解决单继承的局限性
	类在继承的同时也是可以实现接口的
注：类和类之间的关系是继承关系，接口和类之间是实现关系，接口和接口之是继承关系
问：java中有多继承吗？
	类没有多继承
	接口之间多继承
接口的好处：
 	1，扩展了功能
 	2，接口其实就是暴露出来的规则
 	3，接口的出现降低了耦合性，即设备与设备之间产生了解耦
	

接口和抽象的区别
	相同点
		都位于继承的顶端，用于被其他类实现或继承
		都不能直接实例化对象
		都包含抽象方法，其子类都必须复写这些方法
	区别
		抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码的重用性，接口只能包含抽象方法
		一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口，（接口弥补了java 的单继承）
		抽象类是这个事务中应该具备的内容
		接口是这个事务中的额外的功能
二者选用：
	优先选用接口，尽量少用抽象类
	需要定子类的行为，又要为子类提供共性功能时才选用抽象类