Java笔记1

学呗q还能怎么办
117 阅读12分钟

​

JAVA笔记

​

​

从零开始

​

多写代码 多写笔记 多写文章

多交流 多练思维 多练技能

多分享知识 多提问 多思考

​

多坚持

这是重点

​

先学习一下 Markdown语法

轻量级标记语言

我要继续

三个 ---就是分割线

这是一个超链接

字体变粗

像SB一样努力 就会变得NB

截图

加载图片 这就是插入图片

代码

public static void mian 
    

博客 Blog 网络日记

我们需要总结 自己学过的东西

提升语言的组织能力

提升学习的总结能力

提升逻辑思维能力

在哪里写博客呢,,, 写程序没有逻辑思维能力 我需要一个知识库

只有在学习的时候 才有时间 写博客 冰冻三尺非一日之寒

封装

通过 private , default , protected , public 关键字 实现属性或方法的封装

实现数据项和方法的隐藏 允许外部对类做有限访问

方法

1.定义

用来完成特定功能的代码片段

修饰符:修饰符是可选的 告诉编译器如何调用方法 定义了方法的访问类型

返回值:可能会有 没有返回值用void

方法名:方法的实际名称

参数类型:像一个占位符

  • 形式参数 :用来定义的
  • 实际参数 : 实际调用时传递的参数

方法如果存在返回值需要用return,是void就不用

遇到return方法就结束了

2.方法的调用

3.方法的重载

同一个方法的参数类型不同

名称必须相同 参数列表必须不同

可变参数

参数类型后加...

递归

递归就是一个方法自己调用自己

用简单程序解决复杂问题

两个部分

递归头 什么时候调用自己

数组

1.定义

有相同类型数据的有序集合 数组就是一个对象

相同类型的若干个数据 按照一定的先后次序排列组合而成

是一种引用数据类型

动态初始化 指定长度

数据类型[]数组名称 = new 数据类型[数组长度];

int[] arrayA = new int[300];

静态初始化 指定内容

根据数据数量推算长度

数据类型[]数组名称 = new 数据类型[]{元素,}

int[] arrayC = new int[]{5,6,15};

省略写法:

int[] arrayA = {10, 20, 30};

遍历数组 将数组中的每一个元素都打印出来

使用循环 此时就是数组的长度

int len = array.length;
for(int i = 0; i < len;j i++)
    sout(array[i]);

数组反转

初始化语句 : int min = 0,max = array.length - 1,

条件判断 min < max

步进表达式: min++ , max--

循环体:用第三个变量倒手

for(int min = 0,max = array.lengh - 1,min < max; min++, max--){

int temp = array[min];

array[min] = array[max];

array[max] = temp;

}

内存分析

Java的内存划分成五个部分

1.栈(Stack) :存放方法中的局部变量(方法的参数,或者是方法{}内部变量 ,有作用域,一旦超出作用域,立刻从栈内存当中消失)

方法运行在栈当中

2.堆(Heap) : 凡是new出来的东西,都在堆当中,堆内存里面的东西都有一个地址值:16进制.堆内存的数据都有默认值,规则 整数默认为0 浮点数0.0 字符默认为"\u0000" 布尔默认是false 引用类型默认为null

3.方法区(Method Area):存储.class(.java编译后用来运行的JAVA文件)相关信息,包含方法的信息.

4.本地方法栈:与操作系统相关

5.寄存器(pc Register) : 与CPU相关

方法

命名 : 小驼峰

方法好比工厂 参数就是原料 返回值就是产出物

参数 :进入方法的数据

返回值 :从方法中出来的数据

调用 单独调用:方法名称(参数)

打印调用:sout(方法名称(参数))

赋值调用: 数据类型 变量名称 = 方法名称(参数)

注意事项:

1.方法定义在类当中 但是不能在方法中

2.方法定义的前后顺序无所谓

3.方法定义后不会执行,如果希望执行,要调用(单独,打印,赋值)

4.如果方法有返回值 必须写上"return"返回值

5.return后面的返回值数据,必须和方法的返回值类型,对应

6.对于没有返回值的方法,不能写return后面的返回值,只能写return自己.,,,方法最后一行的return可以不写

7.一个方法中可以有多个return语句,但只能保证同时只有一个会被执行

重载(OverLoad)

多个方法的名称一样,但是

参数列表不一样(1.参数个数不同

2.参数类型不同 3. 参数的多类型顺序不同)

在调用输出语句的时候,println就是进行了多种数据类型的重载形式.

类

类是一组相关属性和行为的集合,可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物

属性 :该事物的状态信息

行为: 就是事物能做什么

对象

类是对一类事物的描述 是抽象的

对象是一类事物的实例 是具体的

类是对象的模板 , 对象是类的实体

类里面只有 属性(字段)和方法

类是抽象的 需要实例化

面向对象

以类的方式组织代码 以对象的组织封装数据

使用new 关键字创建的时候 会分配内存空间

会进行默认的初始化 以及调用类中的构造器

一个类即使什么都不写 都会存在一个构造器

API

Scanner

引用类型

导包 : inport 包路径.类名称

如果需要使用的目标类和当前类位于同一包就可不写 (只有Java.lang包下的内容不需要导包,其他包都需要 import)

创建 :

类名称 对象名 = new 类名称();

使用: 对象名.成员方法名()

scanner类 可以实现键盘输入数据到程序当中

匿名对象

匿名对象只有右边的对象,没有左边的名字和赋值运算符

匿名对象只能使用唯一一次,下次再用只能再new一个新对象 如果确定有一个对象只需要使用唯一一次,就可以使用匿名对象

匿名对象 : new 类名称();

对象数组

任何数据类型都可以作为数组当中元素的类型

一旦创建 程序运行期间长度不能发生改变

集合

Collection所有单列集合的父接口 单例集合(Lise和Set)是Collection的子类(每次操作的时候都只能保存一个对象的数据)

HashMap

ker varel

多线程

进程是一个应用程序(一个进程是一个软件)

线程是一个进程中的执行场景/执行单元

一个进程可以启动多个线程

线程基本状态

新建状态

就绪状态

运行状态

阻塞状态

死亡状态

线程创建的两种基本形式

1.继承Thread类 ,重写该类的run方法

2.实现Runnable接口 并重写该接口的run方法

IO

input 和 out

五个类和一个接口

file: 文件特征与管理 目录文件名

InputStream : 二进制格式操作 所有输入流的父流

分类

字符流和字节流

字节流 :

JDBC

1.注册驱动

2.获取链接

3.获取预处理对象

4.执行sql语句

5.遍历结果集 封装

ArrayList集合

只能是引用数据类型 因为集合中都是地址值,但可以使用对应的

1.5

包装类基本数据类型首字母大写 Integer和Character特殊

数组长度不可变 但是 ArrayList可变

有一个<>代表泛型 也就是装载集合中的所有元素,全是统一的类型 泛型只能是引用类型 ,不能是基本类型

list.add("");添加说明的类型

常用方法

public E get(int index) 从集合中获取元素,参数是索引元素

publi E remove(int index) 删除 参数是索引编号 返回值是被删除掉的元素

int size() 获取集合的尺寸长度 返回值是集合中包含的元素个数

类Arrays

Math

abs 绝对值 floor 向下取整

String

程序当中所有双引号字符串都是 String的对象

字符串是常量

字符串效果上相当于char[]字符数组,底层原理是byte[]字节数组

创建字符串

三种构造方法

public String();创建空白字符串,不含内容

public String (char[] array) 根据字符数组内容 创建对印的字符串

public String( byte[] array):

字符串常用方法 :

static

用了Static关键字 类的内容由类中的对象共享

静态方法不属于对象,而属于类

没有Static 需要首先创建对象 才能使用

类名 点 静态方法

静态不能直接访问非静态,在内存中先有静态内容 后人知先人

静态方法不能使用this关键字

静态代码块用来一次性的对静态变量赋值

难点

导包: 指出需要使用的类在什么位置

创建:类名 对象名 = new 类名()

使用: 分为两种情况

1.使用成员变量: 对象名.成员变量名

2.使用成员方法: 对象名.成员方法名()

参数写代码

对象的内存图

方法区先有 .class相关数据,包含成员变量,成员方法

new出来的对象在堆里面,对象通过地址值参考方法区的类拿值

当一个对象作为参数,传递到方法中时,实际上传递进去的是对象的地址值

main方法先进栈,

当使用一个对象类型作为方法的返回值时,返回值就是对象的地址值

成员变量与成员变量

1.定义的位置不一样

局部变量: 在方法的内部

成员变量: 在方法外部 直接写在类中

2.作用范围不一样

局部变量: 方法当中使用,出方法不行

成员变量: 整个类都可以通用

3.默认值不一样

局部变量: 没有默认值,如果要想使用,必须手动赋值

成员变量 : 如果没有赋值,会有默认值,规则同数组

方法的参数就是局部变量,参数在方法调用时,必然会被赋值

4.内存的位置不同

局部变量跟着方法走位于栈中

成员变量在NEW的对象中 位于堆内存

5.生命周期不同

局部变量 随着方法进栈而诞生,随着方法出栈而消失

成员变量: 随着对象创建而诞生,随着对象被垃圾回收而消失

封装

封装在java中的体现

1.方法就是一种封装

主方法main只管调用其他方法

2.关键字private也是一种封装

可对需要保护的成员变量进行修饰

private int age 本类当中可随意访问,超出不能直接访问 可用专门的 public void setAge(int num){

age = num;

} 向age设置数据 getAge无参用来往外拿 用return返回

类的封装 将信息隐藏在类的内部 通过 getter setter方法对隐藏的信息进行操作和访问 修饰符为private

this

当方法的局部变量和类的成员变量重名时,根据就近原则,优先使用局部变量

如果需要访问本类中的成员变量,需要使用this.成员变量名

通过谁调用的方法谁就是this this就出现在方法内部

构造方法

专门用来创建对象的方法,当我们通过关键字new来创建对象时,其实就是在调用构造方法

格式:

public 类名称(参数类型 参数名称,多个用,隔开/没有就不写){
    方法体
}
​
​

1.构造方法的名称必须和所在类名称完全一样

2.构造方法不写返回值类型,void也不写

3.构造方法不能return一个具体的返回值

4.如果没有编写任何构造方法,呢么编译器会默认赠送一个构造方法,没有参数,方法体什么事都不做,

5.构造方法也是可以进行重载的(重载: 方法名称相同,参数列表不同)

标准类

一个标准类由以下四个组成部分组成

1.所有成员变量都要使用private关键字修饰

2.为每一个成员变量编写一对Getter/Setter方法

3.编写一个无参数的构造方法

4.编写一个全参数的构造方法

标准类也叫做Java Bean

public class Student{
    private String name;
    private int age;
}

继承

主要解决的问题是 共性抽取

父类/超类 子类/派生类 共用的东西写一遍

子类可以拥有父类的内容

调用方法 方法属于谁就调用谁 没有则向上找

单继承一个类的直接父类只能有一个

基类Object是所有类的父类,有很多方法

extends 子类会获得父类除私有之外的属性和方法

子类重写父类方法 : 名字一样 内容改

接口

就是一种公共的规范标准,只要符合标准可通用

public interface 接口名称{}

接口里所有方法都是抽象的 public abstract

变量只能为 public static final(公有静态常量)类型

抽象方法 固定关键字 public abstract(可省略)

pulic interface

多态

多态 同一个行为具有不同表现形式或形态的能力

extends继承implements 和 重写是实现多态的前提 就是 继承 重写

父类P S继承P 实例化P

P p = new S();通过子类实例化父类

一个对象拥有多个形态

父类名称 对象名 = new 子类名称();

接口名称 对象名 = new 实现类名称();

异常

程序在运行中,出现非正常情况 导致java虚拟机非正常停止

运行时异常和非运行时异常

try {}catch{} finally{}

throws在方法后面,是方法可能会抛出的异常声明(用在声明方法是,表示该方法可能要抛出异常)

重写 (Overload) 覆写

子类中出现和父类一摸一样的

方法的名称一样,参数列表也一样

@Override 写在方法前 检测是否有效覆写

父类方法被子类重写

返回值类型 方法名 参数列表相同

重载

需要发生在一个类中 出现多个同名的方法

名称相同 参数类型不同

this

Java为解决变量的命名冲突引入

1.构造方法中该构造器 所创建的新对象

2.用在方法中 调用方法中的对象

3.不能用在静态方法中

super

子类通过Super. 调用父类方法''

static

static{

会在类加载之前 加载静态代码块的内容

}

被Static 关键字 修饰的 可通过类名.直接调用

final

被修饰的类不能被继承

抽象类

在类前加abstract修饰

其中可以有 普通变量 公共静态变量

普通方法 抽象方法(不能有方法体)

常用类库

JAVA SE总结

jdk 开发者工具包

jre 运行环境

java关键字

abstrzct 抽象的

assert 断言

boolean 布尔值

enum 枚举

extends 继承

final 常量

protected 受保护的 同包可访问不同级

数据类型

基本数据类型

整数 byte short int(默认) long

浮点数 float double(默认)

字符 char 2字节 ascil编码 utf-8

布尔值 boolean

引用数据类型

类

接口

数组

变量和常量

作用域

类变量 static

实例变量 无static

局部变量

常量 final 常量名一般大写

命名规范

1.见名知意

2.驼峰命名 (用于变量和方法)

3.类的首字大写 加驼峰

4.常量 大写加下划线

5.不要使用拼音命名

运算符

  1. 算术运算符

    • 加 减 * / % ++ --

  2. 赋值运算符

    • =

  3. 关系运算符

    • < > <= >= == !=

  4. 逻辑运算符

    • && || !

  5. 位运算符

    • & | ^(异或) >> 位移

  6. 条件运算符

    • ? :

  7. 扩展运算符

    • += a+=1 a=a+1

包机制

  1. 域名倒写 (防止命名冲突)
  2. package 创建包 必须放在第一行
  3. import 导入包

/**

*/

JavaDoc

JDK帮助文档 javadoc命令

@author 作者 @version 版本

@Since最少哪个版本可以使用

方法相关

@param 参数

@return

@throws

流程控制

  1. 顺序结构

    • 程序默认 顺序执行

  2. 选择结构

    • if单选择结构

    • if - else双选择结构

    • if- else if- else 多选择结构

    • switch

      • case穿透现象 不加break就会被穿透
      • default

  3. 循环结构

    • while 尽量避免死循环

    • do while

    • for (可计次数的一般用for 不可计次数的用while)

    • for each

      break & continue

      break 跳出循环

      comtinue 终止当此循环 继续下次循环

      return: 结束方法运行

方法

  1. 完成特定功能的代码块 语句块的集合

  2. 定义

    • 修饰符 返回值 方法名(参数名){return 返回值}

  3. 方法调用

    • 类名.方法
    • 对象.方法

  4. 方法重载

    • 名字相同 参数列表不同

  5. 命令行传递参数

    • 给main方法传递参数

  6. 可变长参数

    • ...必须放在最后一个参数

  7. 递归

    • 自己调用自己,给自己一个出口

数组

  1. int[] names;

    nums = new int[10];

    必须是同一类型

  2. 使用

    • 通过下标拿到值
    • ArraylndexoutofBounds 数组下标越界异常

  3. for each(增强for循环遍历)

  4. 二维数组

    • int

  5. Arrays 工具类

  6. 排序算法

    • 冒泡排序
    • 选择排序
    • 插入排序
    • 快速排序
    • 归并
    • 希尔
    • 堆排序
    • 基数排序

面向对象

  1. 类与对象

    • 类是对象的抽象 :模板Class
    • 对象是类的具体

  2. 构造方法

    • 构造的重载
    • 有一个默认的无参构造
    • 如果手动定义了有参构造就必须要手动加一个无参
    • 单例模式,需要构造器私有

  3. new 对象

    • 栈存放应用
    • 堆存放具体对象

封装

  1. 属性私有 提供public的get 和 set方法

继承

  1. extends
  2. Object是所有类的老祖宗
  3. 子类拥有父类全部特性
  4. 方法重写
  5. this
  6. super
  7. 只能继承一个父类 Java是单继承

多态

  1. 父类的引用指向子类的对象
  2. 父类变量接受子类对象
  3. instanceof关键字,如果匹配可以进行类型之间的转换

修饰符

  1. public
  2. protected
  3. private
  4. static
  5. abstract

接口 interface

  1. 是一种约束 只能定义方法名
  2. 子类实现接口,必须重写方法
  3. 只有一个方法的接口叫函数式接口,可以使用lambda表达式简化
  4. 抽象类中可以有具体的实现 接口比抽象类更抽象
  5. 一个类可以实现多个接口

内部类

  1. 局部内部类

  2. 成员内部类

  3. 静态内部类

    • 在方法外面 类里面

  4. 匿名内部类(重点)

    • 在方法里面

异常

  1. 总接口:Throwable

    • Exception

      • 运行时异常

        • 1/0
        • ClassNotFound
        • NullPoint 空指针
        • UnKnowType为止类型
        • 下标越界异常
        • ......

      • 检查型异常

    • Error

      • AWT错误

      • JVM错误

        • StackOvaerFlow 栈溢出 递归不停出现
        • OutOfMemory 内存溢出 数字过大时

  2. 处理异常 五个关键字

    1. try{}
    2. catch(){} 先小后大
    3. finally{}
    4. throw 内部手动抛出异常
    5. throws 方法抛出异常

  3. 自定义异常 继承Exception类

常用类

  1. Object类

    • hashcode()

  2. Math类

  3. Random类

    • 生成随机数

  4. file类

    • 创建文件
    • 查看文件
    • 修改文件
    • 删除文件

  5. 包装类

    • 自动装箱和拆箱

  6. Date类

  7. Stringl类

    • 不可变性

  8. StringBuffer

  9. StringBuilder

IO流

\

avatar
文章
阅读
粉丝