JavaSE(停更)
简介: 本博客适合有一定基础,了解hello world java程序编写的小伙伴浏览,其次是作者参考一些B站的视频整理出来的Java笔记。毕竟好记性不如烂笔头,防止偷玉米丢苞谷,整理一下学过的知识点。
没有基础的小伙伴可以看看视频参考视频 感谢秦疆老师的视频
目录结构
安装JDK
如何卸载JDK
如何打开环境变量: win(田标识的键)+e 右键属性-> 高级系统设置->环境变量
在环境变量中找到java_home指向的路径,将下面的jdk目录删除
删除java_home环境变量
并在path中删除带有java_home的环境变量
在cmd命令行输入java -version出现java不是内部或外部命令证明删除成功
安装JDK
-
百度搜索下载jdk (安装对应电脑操作系统的jdk 推荐1.8) 下载地址
-
双击安装
-
记住安装的目录
-
在环境变量中添加JAVA_HOME变量指向安装的目录 (参考卸载JDK)
-
配置path变量添加两个值(参考卸载JDK的图)
-
在cmd命令行输入java -version出现下述证明安装成功
JAVA IDE
这里首推IDEA (可以在网上找资源,) 很好的一款java开发编译器
其次eclipse ,vscode也可以运行java vscode 配置环境(免费)
Java程序运行机制
-
编译型
- 使用专门的编译器，针对特定的平台，将高级语言源代码一次性的编译成可被该平台硬件执行的机器码，并包装成该平台所能识别的可执行性程序的格式。
- 例如将中文书直接翻译为英文书,这样无论什么时候外国人随时都能读懂,这里外国人指代的就是电脑,使用编译器将程序编译为机器可以识别的机器码
- 特点: 在编译型语言写的程序执行之前，需要一个专门的编译过程，把源代码编译成机器语言的文件，如exe格式的文件，以后要再运行时，直接使用编译结果即可，如直接运行exe文件。因为只需编译一次，以后运行时不需要编译，所以编译型语言执行效率高。
-
解释性
- 使用专门的解释器对源程序逐行解释成特定平台的机器码并立即执行。
- 当外国人需要阅读中文书时,旁边会有一个翻译官,当外国人想要阅读某一段时,由翻译官现场翻译,但是当回过头要继续查看之前的段落时,翻译官又要重新翻译,
- 特点: 解释型语言不需要事先编译，其直接将源代码解释成机器码并立即执行，所以只要某一平台提供了相应的解释器即可运行该程序。
-
java程序运行机制
Java基础语法
- 注释,标识符,关键字
- 数据类型
- 类型转换
- 变量,常量
- 运算符
- 包机制,javaDoc
注释
注释是什么?
- 平时我们编写代码,在代码比较少的情况下,我们还可以看懂我们自己的代码,但是当项目结构一旦复杂起来,我们就需要注释了
- 注释并不会被执行,是为了帮助我们写代码的人更好的了解代码的作用
- 书写注释十分重要,在工作中必不可少
注释的分类
- 单行注释
- 用于注释方法中某行代码的含义 适用于简单的注释 (注释只能写在一行内)
- 多行注释
- 可以注释一段文字
- 文档注释
- 放在方法上,或类上,注释类或方法的含义
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9iSrUmBn-1591349251904)(C:\Users\车泽平\AppData\Roaming\Typora\typora-user-images\1591178193777.png)]
标识符和关键字
-
Java中的关键字
-
关键字 含义 abstract 表明类或者成员方法具有抽象属性 assert 断言，用来进行程序调试 boolean 基本数据类型之一，声明布尔类型的关键字 break 提前跳出一个块 byte 基本数据类型之一，字节类型 case 用在switch语句之中，表示其中的一个分支 catch 用在异常处理中，用来捕捉异常 char 基本数据类型之一，字符类型 class 声明一个类 const 保留关键字，没有具体含义 continue 回到一个块的开始处 default 默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现 do 用在do-while循环结构中 double 基本数据类型之一，双精度浮点数类型 else 用在条件语句中，表明当条件不成立时的分支 enum 枚举 extends 表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口 final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量 finally 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块 float 基本数据类型之一，单精度浮点数类型 for 一种循环结构的引导词 goto 保留关键字，没有具体含义 if 条件语句的引导词 implements 表明一个类实现了给定的接口 import 表明要访问指定的类或包 instanceof 用来测试一个对象是否是指定类型的实例对象 int 基本数据类型之一，整数类型 interface 接口 long 基本数据类型之一，长整数类型 native 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的 new 用来创建新实例对象 package 包 private 一种访问控制方式：私用模式 protected 一种访问控制方式：保护模式 public 一种访问控制方式：共用模式 return 从成员方法中返回数据 short 基本数据类型之一,短整数类型 static 表明具有静态属性 strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循[IEEE 754](https://baike.baidu.com/item/IEEE 754)算术规范 super 表明当前对象的父类型的引用或者父类型的构造方法 switch 分支语句结构的引导词 synchronized 表明一段代码需要同步执行 this 指向当前实例对象的引用 throw 抛出一个异常 throws 声明在当前定义的成员方法中所有需要抛出的异常 transient 声明不用序列化的成员域 try 尝试一个可能抛出异常的程序块 void 声明当前成员方法没有返回值 volatile 表明两个或者多个变量必须同步地发生变化 while 用在循环结构中
-
标识符(变量名)
-
所有的变量名(类名,方法名) 都是以字母,下划线,$符号开头
-
之后可以是字母,数字,下划线,$符号,的任意字符组合(注意变量名不可以是上述关键字)
-
变量名是大小写敏感的, int A;和 int a; 是两个变量
-
可以使用中文或拼音命名,但是不易阅读理解含义,代码没有美感, 例如 int wdrmb = 1000;(我的人民币首字母小写)如果没有注释很难理解其含义
-
数据类型
数据类型的分类
-
强类型语言
- 要求变量的使用要严格符合规定,所有的变量要先定义(初始化后在使用 个人习惯, 防止一些异常)
- 如何初始化: 比如 int i = 0; 对变量进行赋值, 如果是复杂类型,赋值为null, 比如 String name = null;
- java是强类型语言
-
弱类型语言
- 变量在定义时不知道其具体的类型只有在使用过程中才能确定 比如javaScript
Java的数据类型的分类
-
基本类型
- 整数拓展
- 二进制使用 0b开头表示
- 八进制使用 0 开头表示
- 十六进制使用0x开头表示
- 浮点数拓展
- 银行业务怎么表示钱
*
- 字符拓展
- 银行业务怎么表示钱
- 整数拓展
-
引用类型
类型转换
- 由于java是强类型语言,所以要进行运算时,需要进行类型转换
- byte,short, char-> int -> long -> float -> double
- 运算中.不同类型的数据先转换为同一类型,然后再进行运算
类型转换的类型
- 强制类型转换
- 高 – 低
- 自动类型转换
- 低 – 高
注意
- 不能对布尔值转换
- 不能把对象类型转换为不相干的类型
- 再把高容量转换为低容量时,需要强制转换
- 转换时可能会出现内存溢出,或者是精度问题
变量
- 变量的分类
- 局部变量
- 必须声明和初始化
- 生命周期 : 再声明的代码块内
- 实例变量
- 从属于对象
- 对象如果不进行初始化,会变成默认值
- 初始值: short: 0; byte: 0;int: 0; long:0; float: 0.0; double: 0.0; boolean : flase; char的初始值: /u0000 (unicode编码 显示为空);
- 从属于对象
- 局部变量
运算符
- Java支持的运算符
- 算术运算符: +, -, *, /, ++
- a++和++a的区别: a++是先进行赋值再自增, ++a是先进行自增再进行赋值
- 幂运算: 借助Math提供的pow方法 比如: 2^3: Math.pow(2,3);
- a++和++a的区别: a++是先进行赋值再自增, ++a是先进行自增再进行赋值
- 赋值运算符: ==
- 关系运算符: >, < , >=, <= , ==, !=, instanceof
- 逻辑运算符: &&, ||, !
- 位运算符: &, | , ^, ~, >>, <<, >>>
- 条件运算符: ? :
- 扩展赋值运算符: +=, -=, *=, /=
- 算术运算符: +, -, *, /, ++
包机制
有什么用处?
- 为了更好的组织类,用于区别类名的命名空间
怎么用?
- 一般利用公司域名倒置作为包名
- 为了能够使用包中的一个成员,我们需要在java程序中明确导入该包,使用import 导入
JavaDoc生成文档
干什么?
- JavaDoc命令是用来生成自己的API文档的
参数信息的含义
- @author 作者
- @version 版本号
- @since 指明兼容的最低版本JDK
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
如何生成
- 命令行窗口打开项目位置 输入 javadoc -encoding utf-8 -charset utf-8 [项目名] 即可
Java流程控制
用户交互Scanner
干什么?
- 使用Scanner获取用户的输入 ( 必须是JDK1.5版本之后)
怎么用?
-
Scanner scanner = new Scanner(System.in); //创建输入流 scanner.next(); //读取用户输入的字符 以空格结束 scanner.nextLine(); //读取一行 -
再读取前我们可以使用hasNext();和hasNextLine()方法来判断是否还有输入的数据
-
再使用完后关闭IO流
结构
-
顺序结构
- 从上到下,一行一行执行
- java中最基础的结构
-
选择结构
-
if 单选择结构
- 判断一个条件是否满足,满足则执行,不满足则不执行
-
多选择结构
-
if else
-
if(a) { //如果a为真,执行此代码块代码 } else if (b) { // 如果a为假,b为真,执行此代码块方法 } else { //如果a和b条件都不满足.则执行此代码块方法 }
-
-
switch
-
Switch case 判断一个变量与一系列值中的某个值是否相等,每一个值称为一个分支
-
switch语句中的变量可以是 byte short int char String(JDK1.7及其以后支持)
-
int a = 10; switch (a){ case 1: System.out.println(a); //注意如果case后面的语句如果没有break会连着执行下面的语句直到遇见break为止 case 2: System.out.println(a); break; case 10: System.out.println(a); break; //如果上述都不满足,则走default默认分支 default: System.out.println(a); break; }
-
-
-
循环结构
-
while循环
-
while(条件) { //如果条件为真,代码块会一直执行 }
-
-
do…while循环
-
循环至少执行一次
-
do{ } while(条件) -
和while循环的区别
- while 先进行判断后执行,doWhile 是先执行后判断
- Do…while 总是保证循环体至少执行一次
-
-
For循环
-
for(初始化; 布尔表达式; 更新) { } -
也可以写成如下格式
-
int i = 0; for(;i < 10;){ i++; System.out.println("i的值为:" + 1); }
-
-
-
增强for循环
-
遍历一个数组,集合,
-
for(声明子集: 要遍历的超集) { } //例如 int[] i = {0,1,2,3,4,5}; for (int temp : i) { System.out.println(temp); }
-
-
-
-
break continue
-
break
- break 在任何循环语句的主体部分,均可使用break控制循环的流程
- 用于强制退出当前循环
-
continue
- 用于终止本次循环
-
java中没有goto语句,但保留了goto关键字
-
break 和continue后面可以加上标签表示跳转到标签
-
outer:for(int i = 0; i < 10; i++){ System.out.println(); for(int j = 0; j < 10; j++){ if(j == 5){ continue outer; } System.out.print(j); } //由于每次终止都会跳转到外部所以后面的代码不执行 System.out.println("这里的代码不执行"); }
-
-
java方法
什么是方法?
- java方法是语句的集合,他们在一起执行一个功能
- 方法是解决一类问题的步骤的有序集合
- 方法包含于类或对象中
- 方法在程序中被创建,在其他地方被引用
- 设计方法的原则:
- 原子性: 一个方法只完成一个功能,利于后期扩展
- 方法的命名规则: 驼峰命名规则
方法的定义?(如何创建一个方法)
-
方法包含一个方法头和一个方法体
-
修饰符: 可选,告诉编译器如何调用该方法,定义了该方法的访问类型(private,public, protected)
-
返回值类型: 方法可能会返回值(int, string,… 八大基本数据类型和引用类型),有的没有返回值(用void修饰)
-
方法名: 是方法的实际名称,方法名和参数列表共同构成方法签名(方法名(类型1 参数1, 类型2 参数2))
-
参数类型: 当方法被调用时,传递值给方法进行操作,这个值被称为实参或变量可以有或没有参数
- 传递值的两种方式
- 按值传递
- 将栈中变量的值拷贝一份传递给方法
- 返回时不改变原变量的值
- 按引用传递(也可以称为按值传递,因为它拷贝的是栈中存放的引用对象的地址)
- 若方法中改变原对象的属性返回时,也一起改变
- 按值传递
- 传递值的两种方式
-
方法体: 方法体中包含具体的语句,定义该方法的功能
-
修饰符 返回值类型 方法名(参数类型 变量名){ ... 方法体 ... return 返回值; }
-
方法的重载(同名方法如何区分)
-
根据参数列表的不同和参数的类型的不同来区分
-
不可以包含同名同参方法(有歧义,java无法区分调用哪个方法)
-
重载的定义:
- 方法名称必须相同
- 参数列表不同(个数不同, 类型不同,参数排列顺序不同)
- 返回值类型可以不同
- 仅仅返回值类型不同不能区分成分方法重载
递归
- 递归结构包含两个部分
- 递归就是自己调用自己
- 递归头: 什么时候不调用自己,如果没有头,将陷入死循环
- 递归体: 什么时候需要调用自身方法
数组
什么是数组?
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成
- 其中,每一个数据称之为一个数组元素,每一个数组元素可以通过一个下标来访问他们
怎么使用数组?
-
首先必须声明数组变量,才能在程序中使用数组
-
dataType[] array; //推荐 或 dataType array[];
-
-
java使用new关键字来创建数组
-
int[] array = new int[10];
-
-
或者在创建时就为其赋值
-
int[] array = {1,2,3,4,5}; //这样array就是一个长度为5的一个int类型的数组了 //注意数组时定长的,当长度确定之后就不能改变了
-
数组的特点
- 其长度是确定的,数组一旦被创建,他的大小就是不可以改变的
- 其元素必须是相同类型,不允许出现混合类型
- 数组中的元素可以是任何数据类型,包括基本类型和引用类型
- 数组变量属于引用类型,数组也可以看成为对象,数组中的每个元素相当于该对象的成员变量
- 数组本身就是对象,java中对象是在堆中的,因此数组无论保存原始类型还是其他类型其还是在堆中存储
- 当要使用一个在数组中不存在的下标时,就会出现数组下标越界异常(C和C++对此没有严格的定义)
- ArrayIndexOutofBandsException: 数组下标越界异常
如何理解多维数组
-
多维数组是对一维数组的扩展
-
可以和一维世界二维世界联系起来比较
-
二维数组就是无数个一维数组的聚集,高维数组同理
-
//二维数组 int[][] array = {{1,2,3},{4,5,6}}; //获取二维数组的第一行 int[] firstArray = array[0]; //输出 for (int i : firstArray) { System.out.println(i); } //输出结果为 1 换行 2 换行 3
-
Arrays类(utill常用类)
-
常用方法
-
fill()
-
//給firstArray的所有元素赋值为1 Arrays.fill(firstArray, 1); for (int i : firstArray) { System.out.println(i); }
-
-
sort()
-
//对数组排序 int[] array = {5,3,3,25,67} ; Arrays.sort(array); for (int i : array) { System.out.println(i); }
-
-
binarySearch()二分查找
-
//源码 //开始 int low = fromIndex; //结尾 int high = toIndex - 1; //当寻找范围存在时查找 while (low <= high) { //中间下标 无符号逻辑右移1位相当于除以2 int mid = (low + high) >>> 1; //获得中间数字 int midVal = a[mid]; //判断是否找到,找到返回下标, 没有缩小范围 if (midVal < key) low = mid + 1; else if (midVal > key) high = mid - 1; else return mid; // key found } //没有找到返回负数 return -(low + 1); // key not found.
-
-
八大排序算法
冒泡排序
-
每次对数组中的两个元素进行比较,并将较大的放到后面,较小的放到前面
-
这样共需比较length-1轮就能对数组完成排序,每轮需要比较length-1-轮数次
-
public static void printArray(int[] array){ for (int i : array) { System.out.print(i + " "); } } public static void main(String[] args) { int[] array = {5, 3, 3, 25, 67}; for (int i = 0; i < array.length - 1; i++) { for (int j = 0; j < array.length - i - 1; j++) { if (array[j] > array[j+1]){ int temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } Test.printArray(array); }
-
快速排序
详见大佬博客
-
先从数列中取出一个数作为基准数。
-
分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
-
再对左右区间重复第二步，直到各区间只有一个数。
-
public static void main(String[] args) { int[] array = {5, 3, 3, 25, 67}; quick_sort(array, 0, array.length-1); printArray(array); } /** * 挖坑填数 * 先从数列中取出一个数作为基准数。 * 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 * * @return 为基准数选择的合适的下标 */ public static int adjustArray(int[] array, int begin, int end) { int temp = array[begin];//要为基数寻找合适的位置 int i = begin, j = end; while (i < j) { //从右向左找到一个比基准数小的下标 while (i < j && array[j] >= temp) j--; if (i < j) { array[i] = array[j]; //将array[j]填到array[i]的坑中,同时形成array[j]一个新坑 i++; } //从左向右摘到一个比基准数大的数的下标 while (i < j && array[i] < temp) i++; if(i < j){ array[j] = array[i]; //将array[i]填到array[j]的坑中,同时形成array[i]一个新坑 j--; } } //循环退出时i == j;寻找到temp基准数要填入的坑 array[i] = temp; return i; } /** * 分治算法 * 划分区域对其进行排序 */ public static void quick_sort(int[] array, int begin, int end){ if(begin < end){ int i = adjustArray(array, begin, end); quick_sort(array, begin, i-1); quick_sort(array, i+1, end); } }
选择排序
-
第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，
-
然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。
-
/** * 选择排序 * @param array */ public static void selection_sort(int[] array){ for (int i = 0; i < array.length -1; i++) { int min = i; //找到最小的下标 for (int j = i + 1; j < array.length; j++) { if(array[min] > array[j]){ min = j; } } if(min != i){ int temp = array[i]; array[i] = array[min]; array[min] = temp; } } }
-
堆排序(升序)
详见大佬博客
-
将数组构建成最大堆
-
每次构建时将下标前推移一位(即升序排序好的下标,设为i)
-
当i = 0,说明数组已经完成排序
-
/** * 堆排序 * */ /** * 将指定父节点的数组 * 将其转化为最大堆 */ public static void maxHeap(int index, int len, int[] array) { //左节点 int leftNode = (index << 1) + 1; //右节点 int rightNode = leftNode + 1; //如果左节点不存在直接返回 if (leftNode > len) return; //找出左右子节点中最大的下标 int maxNodeIndex = leftNode; if (rightNode <= len && array[rightNode] > array[leftNode]) maxNodeIndex = rightNode; if (array[index] < array[maxNodeIndex]) { //将这两个元素交换 swap(index, maxNodeIndex, array); //判断交换后的元素是否满足最大堆定义 maxHeap(maxNodeIndex, len, array); } } /** * 交换数组的下标 * * @param beginIndex * @param endIndex */ public static void swap(int beginIndex, int endIndex, int[] array) { int temp = array[beginIndex]; array[beginIndex] = array[endIndex]; array[endIndex] = temp; } public static void sort(int[] array) { int len = array.length - 1; //计算进行堆排序的最小父节点 len - 1是为了优化算法, 让开始排序时都有一个子节点 int beginIndex = (len - 1) >> 1; //将数组转化为最大堆 for (int i = beginIndex; i >= 0; i--) maxHeap(i, len, array); for (int i = len; i > 0; i--) { swap(0, i, array); maxHeap(0, i - 1, array); } }
-
直接插入排序
-
默认第一个元素已经排序好了,将后续元素插入这个有序的数组
-
/** * 插入排序 */ public static void insertSort(int[] array) { for (int i = 1; i < array.length; i++) { int key = array[i]; int j = i - 1; while (j >= 0 && array[j] > key) { array[j + 1] = array[j]; j--; } array[j+1] = key; } }
-
shell排序
-
shell排序是对插入排序的优化
-
具体解释见 希尔(shell)排序的原理解析
-
public static void shellSort(int[] array) { //定义步长为数组的一半,每次折半 for (int stepSize = array.length >> 1; stepSize > 0; stepSize = stepSize >> 1) { for (int i = 0; i < stepSize; i++) { //遍历指定步长的元素 for (int j = i + stepSize; j < array.length; j += stepSize) { int key = array[j]; int k; //在每个遍历到的元素都要和前面的元素进行比较和交换,相当于插入排序,使其按步长有序 //当步长等于1时相当于插入排序 for (k = j - stepSize; k >= 0 && array[k] > key; k -= stepSize) { array[k + stepSize] = array[k]; } array[k + stepSize] = key; } } } }
-
归并排序
参考菜鸟教程
-
将序列中待排序数字分为若干组,每个数字分为一组
-
将若干个组两两合并,保证合并后的组是有序的
-
重复第二步操作直到只剩下一组,排序完成
-
/** * 归并排序 * @param array * @return */ public static int[] mergeSort(int[] array) { int[] arr = Arrays.copyOf(array, array.length); if (arr.length < 2) { return arr; } int middle = (int) Math.floor(arr.length / 2); int[] left = Arrays.copyOfRange(arr, 0, middle); int[] right = Arrays.copyOfRange(arr, middle, arr.length); return merge(mergeSort(left), mergeSort(right)); } /** * 对左右两个数组进行合并 * * @param left * @param right */ public static int[] merge(int[] left, int[] right) { int[] result = new int[(left.length + right.length)]; int i = 0; while (left.length > 0 && right.length > 0) { if (left[0] < right[0]) { result[i++] = left[0]; left = Arrays.copyOfRange(left, 1, left.length); } else { result[i++] = right[0]; right = Arrays.copyOfRange(right, 1, right.length); } } /** * 如果左边的数组多 * 将其拷贝到result中 */ while (left.length > 0) { result[i++] = left[0]; left = Arrays.copyOfRange(left, 1, left.length); } /** * 如果右边的数组多 * 将其拷贝到result中 */ while (right.length > 0) { result[i++] = right[0]; right = Arrays.copyOfRange(right, 1, right.length); } return result; }
-
基数排序
参考菜鸟教程
- 基数排序(Radix Sort)是桶排序的扩展，它的基本思想是：将整数按位数切割成不同的数字，然后按每个位数分别比较。
- 按照个位数进行排序。
- 按照十位数进行排序。
- 按照百位数进行排序。
- 排序后，数列就变成了一个有序序列。
这里博主不太理解代码,有兴趣的可以参考菜鸟教程
java内存分析
(简单概述,后续深入虚拟机,会对其做一个完整的梳理)
java内存分类
- 堆
- 存放新建的对象和数组(真实存放的属性)
- 可以被所有的线程所共享,不会存放别的对象引用
- 栈
- 存放基本变量类型(会包含这个基本类型的数值,比如int,char,byte等)
- 存放引用对象的变量(存放的是堆中真实存放对象的地址)
- 方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量
面向对象
什么是面向对象
- 面向对象编程(Object oriented programing, OOP
- 本质: 以类的方式组织代码,以对象的组织(封装数据)
- 三大特性
- 封装
- 隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。
- 继承
- 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
- 多态(面向接口编程)
- 程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定
- 封装
- 什么是类:
- 类就是拥有相等功能和相同的属性的对象的集合
- 类是一种抽象的数据类型,它是对某一类事物整体的描述/定义,但是并不能代表一个具体的事物
- 什么是对象: 对象就是类的实例
- 内部类的分类
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
- 抽象类 摘自 https://blog.csdn.net/luChenH/article/details/79884287
- 定义 抽象就是从多个事物中将共性的，本质的内容抽取出来。 由abstract关键字修饰的类
- 特点
- 抽象方法只能定义在抽象类中，抽象的方法和抽象的类必须由关键字abstract修饰。
- 抽象类值只定义方法声明，不定义功能主题（即方法的实现）。
- 抽象类不可以被创建对象。
- 抽象类只有子类继承了父类中的方法，并且对其中的所有抽象方法进行了重写。该子类才不是抽象类，只要不是重写当中的所有抽象方法，那么这个子类还是抽象类
- 注意点
- 抽象类中是否有构造函数？有，用于给子类对象进行初始化。
- 抽象类中是否可以定义非抽象方法？可以
- 抽象关键字abstract和哪些不可以共存？final , private , static
- 抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。
- 什么是接口
- 接口定义了一个实体可能发出的动作。但是只是定义了这些动作的原型，没有实现，也没有任何状态信息。
- 接口就是函数声明，类就是函数实现
什么是异常
- 在程序运行中/生活过程中，所发生的不正常的/不符合预期的情况（意外），这就是异常，它会导致程序的中断或者过程的结束
总结
- 如果看完视频并掌握以上知识点,那么恭喜你,已经对java有了一个大概的了解。
- 如果要进行项目的编写,你还要了解包装类,String,I/O流,集合框架等常用类的使用
- 这时你就可以简单用命令行编写一个小小的程序啦
- 当然java,博大精深,只有不断地学习才不会被这个世界淘汰
121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
