Java基础_学习笔记

---

typora-copy-images-to: ./
typora-root-url: ./

常用的dos命令

# 盘符切换
# 查看当前目录下的所有文件 dir
# 切换目录 cd change directory
cd ..
# 清理屏幕  cls  (clear screen)
# 退出终端 exit
# 查看电脑ip  ipconfig

# 打开应用
calc  # 打开计算器
mspaint # 画板
notepad # 打开记事本

# 文件操作
md 目录名	 # 创建目录名
rd 目录名   # 移除目录
cd>文件名  # 创建文件
del 文件名  # 删除文件

卸载JDK

1. 删除java的安装目录
2. 删除JAVA_HOME
3. 删除path下关于java的目录
4. 查看java-version

安装JDK

1. 双击安装jdk

2. 记住安装的路径

3. 配置环境变量

   1. 我的电脑->右键->属性

   2. 环境变量–>JAVA_HOME
      

   3. 配置path变量

   4. 测试是否安装成功

      java version
      

编写一个HelloWorld并运行

1. 编写代码

   public class Hello{
         
         
   	public static void main(String[] args){
         
         
   		System.out.print("Hello,world");
   	}
   }	
   

2. 编译.java文件,会生成.class文件

   F:\4_学习资料>javac F:\4_学习资料\code\Hello.java
   # javac 命令后写绝对路径+文件名即可,如果文件在当前路径下,直接写文件名即可;
   

3. 运行.class文件

   java Hello  # java + 文件名,不用带后缀(需要在Hello目录下运行)--包路径下运行
   

4. 运行机制

   • 编译型
   • 解释型

强制转换

byte,short,char ->int -> long ->float ->double

强制转换: (类型)变量名 高–低

自动转换: 低–高
不能对布尔型转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候,强制转换
转换的时候可能存在内存溢出,或者精度问题

变量

1. 局部变量: 必须声明和初始化,作用域在方法内
2. 实例变量: 从属于对象,不初始化时值为该类型的默认值; 布尔类型默认false
3. 类变量: static修饰

位运算

​ A = 0011 1100

​ B = 0000 1101

A&B = 0000 1100 //l两个都为1 才为1

A|B = 0011 1101 // 有一个为1 即为1

A^B = 0011 0001 (亦或) 位置相同为0, 不相同为1

~B = 1111 0010 // 取反

break 和 continue

• break在任何循环语句的主体部分,君可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch中使用）
• continue语句用在循环语句中,用于终止某次循环过程,即提交过循环体尚未执行的语句,急着进行下一次是否执行循环的判定.

方法的重载

重载就是在一个类转给你,有相同的函数名称,但形参不同的函数.

1. 方法重载的规则:
   • 方法名称必须相同
   • 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)
   • 方法的返回类型可以想听也可以不同
   • 仅仅返回类型不同不足以成为方法的重载
2. 实现理论:
   • 方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

可变参数

一个方法中只能指定一个可变参数,它必须是方法的最后一个参数. 任何普通的参数必须在它之前声明.

内存

堆:

栈:

方法区:

数组

• 其长度是确定的。数组一旦被创建，其大小就是不可改变的;

• 其元素必须是相同类型,不允许出现混合类型;

• 数组中的元素可以是任何数据类型,包括基本类型和引用类型;

• 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于改对象的成员变量。

  数组本身就是对象,Java中对象时在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的.

冒泡排序

1. 比较数组中,两个相邻的元素,如果第一个数比第二个数大,就交换他们的位置

2. 每次比较,都会产生一个最大,或者最小的数字;

3. 下一村可以少一次排序

4. 依次循环,知道结束

       public static int[] sort(int[] array){
         
         
           //临时变量
           int temp = 0;
           // 1.外层循环,判断要走多少次
           for (int i = 0; i < array.length; i++) {
         
         
               boolean flag = false; //  通过flag标识位减少没有意义的比较
               //2.内层循环,比较判断两个数,如果第一个数比第二个数大,就交换位置
               for(int j=0;j<array.length-1-i;j++){
         
         
                   if(array[j+1]>array[j]){
         
         
                       temp=array[j];
                       array[j]=array[j+1];
                       array[j+1]=temp;
                       flag=true;
                   }
               }
               if(flag==false) {
         
         
                   break;
               }
           }
           return array;
       }
   

稀疏数组

• 当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组.
• 稀疏数组的处理方式是:
  • 记录数组一共有几行几列,有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

面向对象

本质: 以类的方式组织代码,以对象的方式组织(封装)数据.
三大特性: 封装、继承、多态

创建对象内存分析

面向对象

1.super与this

1. super注意点:

   1. super调用父类的构造方法,必须在构造方法的第一个;
   2. super必须只能出现在子类的方法或者构造方法中
   3. super和this不能同时调用构造方法

2. this:

   1. 代表的对象不同:

      this: 本身调用者这个对象

      super: 代表父类对象的应用

   2. 前提:

      this: 没有继承也可以使用

      super: 只能在继承条件下才可以使用

   3. 构造方法:

      this() : 本类的构造

      super(): 父类的构造

2.重写

重写: 需要有继承关系,子类重写父类的方法:

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符: 范围可以扩大但不能缩小
4. 抛出的异常:范围可以被缩小,但不能扩大

重写: 子类的方法和父类必须一致,方法体不同

为什么要重写: 父类的功能,子类不一定需要,或者不一定满足;

3.多态

1. 多态是方法的多态,属性没有多态
2. 父类和子类,有联系,
3. 存在条件: 继承关系,方法需要重写,父类引用指向子类对象 Father f = new Son();

4.抽象类

1. 不能new,只能靠子类去实现它:约束
2. 抽象类中可以写普通方法
3. 抽象方法必须在抽象类中

5.接口

• 不同类:只有具体实现
• 抽象类: 具体实现和规范(抽象方法)都有
• 接口: 只有规范;自己无法写方法 --专业的约束

6.内部类

• 成员内部类
• 静态内部类
• 局部内部类

异常处理

属性没有多态
2. 父类和子类,有联系,
3. 存在条件: 继承关系,方法需要重写,父类引用指向子类对象 Father f = new Son();

4.抽象类

1. 不能new,只能靠子类去实现它:约束
2. 抽象类中可以写普通方法
3. 抽象方法必须在抽象类中

5.接口

• 不同类:只有具体实现
• 抽象类: 具体实现和规范(抽象方法)都有
• 接口: 只有规范;自己无法写方法 --专业的约束

6.内部类

• 成员内部类
• 静态内部类
• 局部内部类

异常处理