这里写自定义目录标题
- 基础语法
- 第一个java 程序各个变量的解释
- 标识符
- 关键字
- java注释
- 常量 变量
- 运算符
- 2.7 函数
- 2.8 数组
- 面向对象
- 4 继承
- IO 流
- 功能快捷键
- 合理的创建标题，有助于目录的生成
- 如何改变文本的样式
- 插入链接与图片
- 如何插入一段漂亮的代码片
- 生成一个适合你的列表
- 创建一个表格
- 创建一个自定义列表
- 如何创建一个注脚
- 注释也是必不可少的
- KaTeX数学公式
- 新的甘特图功能，丰富你的文章
- UML 图表
- FLowchart流程图
- 导出与导入
- 欢迎使用马克飞象
跟小马过河一样吧，松鼠说河深，能淹死它，水牛说河浅，才没过膝盖。问题就在于你–是谁了
基础语法
第一个java 程序各个变量的解释
代码块
/*
public static void main(String[] args)
主函数特殊之处：
1，格式是固定的。
2，被jvm所识别和调用。
public:因为权限必须是最大的。
static:不需要对象的,直接用主函数所属类名调用即可。
void：主函数没有具体的返回值。
main:函数名，不是关键字，只是一个jvm识别的固定的名字。
String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。
class MainDemo
{
public static void main(String[] args) //new String[0]
{
/**/
// System.out.println(args);//[Ljava.lang.String;@c17164
System.out.println(args.length);
for(int x=0; x<args.length; x++)
System.out.println(args[x]);
}
}
public class HelloWorld{//public 是提升权限
public static void main(String []args){//1.程序入口 2.被虚拟机调用 3.保证一个类的独立运行。 args 只是一个变量名可以改成其他字符 。
System.out.println(" Hello World");
}
}java MainDemo zengjx haha ahaha
没有开启拓展名情况下可能出现如下情况
文件要开启拓展名否则 123.java.txt
这是看 如果是1.文本文档说明文件后缀是txt 不是java文件 2. 可以输入 dir命令 看到后缀。
javac 123.java ,命令javac 对应 一个编译程序。对.java 的源文件检查语法。
命令java ： java Demo 加载进内存。
classpath环境变量
只是临时设置，窗口关了就没了
set classpath=c:\myclass 没有分号
set classpath=c:\myclass; 加了分号
加了分号会在指定路径下查找，如果没有找到会在当前路径下再查找一次。
（一般不加分号会默认在当前目录下查找一次）
set classpath =.;c:\myclass 应该加“ . ”明确显示在当前路径和指定路径
System.out.println(“b=”+100+100); //输出 1001000
命名规则
- 大小写敏感：Java 大小写敏感
- 类名： 首字母大写，若干单词构成，每个单词的首字母大写。
- 源文件名称：源文件名称必须和类名相同。文件名称.java
类名和源文件名称不同会导致编译错误。 - 主方法入口：public static void main（String []args)
标识符
- 定义：类名，方法名，变量名。被称为标识符 标识符要符合语意。
- 开头：字母，美元$, 或者下划线开头。首字符后可以是字母，美元符，下划线，数字的任何组合。不能以数字开头。
- 关键字保留字不能作为标识符。
- 包名是所有字母小写.
- 类名是每个首字母大写其他小写。
- 变量和方法：第一个单词小写，第二个单词开始首字母大写。
- 常量：所有字母大写，每个单词之间小写。
关键字
下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。
类别 关键字 说明
- 访问控制
private 私有的
protected 受保护的
public 公共的
2.类、方法和变量修饰符**
abstract 声明抽象
class 类
extends 扩充,继承
final 最终值,不可改变的
implements 实现（接口）
interface 接口
native 本地，原生方法（非 Java 实现）
new 新,创建
static 静态
strictfp 严格,精准
synchronized 线程,同步
transient 短暂
volatile 易失
3.循环控制语句
break 跳出循环
case 定义一个值以供 switch 选择
continue 继续
default 默认
do 运行
else 否则
for 循环
if 如果
instanceof 实例
return 返回
switch 根据值选择执行
while 循环
4.错误处理
assert 断言表达式是否为真
catch 捕捉异常
finally 有没有异常都执行
throw 抛出一个异常对象
throws 声明一个异常可能被抛出
try 捕获异常
包相关 import 引入
5.package 包
6.基本类型
整数默认： int 小数默认： double
boolean 布尔型
byte 字节型
char 字符型
double 双精度浮点
float 单精度浮点
int 整型
long 长整型
short 短整型
7.变量引用
super 父类,超类
this 本类
void 无返回值
8.保留关键字 - goto 是关键字，但不能使用**
10.const 是关键字，但不能使用
11.null 空
Java修饰符
像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：
访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized
在后面的章节中我们会深入讨论 Java 修饰符。
java 类变量
Java 中主要有如下几种类型的变量
局部变量
类变量（静态变量）
成员变量（非静态变量）
继承
一个类可以由其他类派生，被继承的类叫做超类 superclass ,派生的类叫做子类 subclass
接口
接口只定义派生用到的方法，但是具体实现完全取决于派生类。
转义字符
“\b” (退格)
“\f” (换页)
“\n” (换行)
“\r” (回车)
“\t” (水平制表符(到下一个tab位置))
"’ " (单引号)
“” " (双引号)
“\” (反斜杠)
面试题： java基本数据类型有哪几种？
数据类型分为 基本数据类型，引用数据类型
基本数据类型
四种 八个
整数型：byte int long double
浮点型： float double
字符型：char
布尔类型：boolean
整数默认： int 小数默认： double
boolean 布尔型 1个字节 8bit（8位）
byte 字节类型 1个字节
char 字符类型 2个字节
short 短整型 2个字节
int 整型 4个字节
float 浮点型（单精度）4个字节
long 长整型 8个字节
double 双精度类型 8个字节
引用数据类型
String 字符串，类，数组，接口，Lambda
Java中默认的整数类型是int，如果要定义为long ，则要在数值后加上L或者l
默认的浮点型是双精度浮点，如果要定义float，则要在数值后面加上f或者F
一个字节等于8位，1个字节等于256个数。2^8
一个英文字母或者阿拉伯数字占一个字节
一个汉字占2个字节
java注释
/**
这是一个 HelloWorld 程序
@author 小强
class Demo
{
/*
这是主函数，是程序的入口
它的出现可以保证程序独立运行
*/
public static void main( String []args){
//单行注释
}
}
*/常量 变量
常量 表示不能改变的数值
Java中常量的分类：6种
1，整数常量。所有整数 2
2，小数常量。所有小数
3，布尔型常量。较为特有，只有两个数值。 true 、 false。
4，字符常量。将一个数字字母或者符号用单引号( ’ ’ )标识。‘a’ ‘2’
5，字符串常量。将一个或者多个字符用双引号标识” “abc” 空字符串 “”
6， null常量。只有一个数值就是:null 没有任何东西情况下就是空 没有任何数据。
整数： java有三种表现形式。
进制
进制是计数的一种方式
• 十进制： 0-9 ，满10进1.
• 八进制： 0-7 ，满8进1. 用0开头表示。 三个bit 000 -777 0123
八进制其实就是二进制 3个 二进制一个八进制位
• 十六进制： 0-9， A-F，满16进1. 用0x开头表示。0x123 ,0xFFFF
4个二进制表示一位16进制
进制的基本转换
• 十进制 二进制 互转
1011 =11
- 0110=6
= 10 0 01=17
• 十进制转成二进制 除以2取余数
• 二进制转成十进制 乘以2的幂数
1011 = 8+2+1 =11
• 十进制 八进制 互转
• 十进制 十六进制 互转
• 负数的二进制表现形式：正数取反加1
-6
0000 0110
取反
1111 1001 - 0000 0001
1111 10 10
负数的二进制最高为1
• 对应的正数二进制取反加1
变量的概念：
• 内存中的一个存储区域
• 该区域有自己的名称（变量名）和类型（数据类型）
• 该区域的数据可以在同一类型范围内不断变化
为什么要定义变量：
• 用来不断的存放同一类型的常量，并可以重复使用
使用变量注意：
• 变量的作用范围（一对{}之间有效）
• 初始化值
定义变量的格式：
• 数据类型 变量名 = 初始化值；
• 注：格式是固定的，记住格式，以不变应万变。
理解：变量就如同数学中的未知数。
自动类型转换（也叫隐式类型转换）
强制类型转换（也叫显式类型转换）
类型转换的原理
什么时候要用强制类型转换?
表达式的数据类型自动提升
• 所有的byte型、 short型和char的值将被提升到int型。
• 如果一个操作数是long型，计算结果就是long型；
• 如果一个操作数是float型，计算结果就是float型；
• 如果一个操作数是double型，计算结果就是double型。
分析
• System.out.println(‘a’)与System.out.println(’a’+1) 的区别。
变量类型转换
自动类型转换：
自动转换，数据范围从小到大。
long num1 =100 ;// int -----》long
double num2=100L;//100.0
自动类型提升
byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。
强制类型转换
byte b = 3;
b = b + 4;//报错
b = (byte)b+4;//强制类型转换，强制将b+4的结果转换为byte类型，再赋
值给b。
思考：
byte b1=3,b2=4,b;
**b=b1+b2;** //这句出错
b=3+4;
**哪句是编译失败的呢？为什么呢？**强制类型转换：
范围小 = （范围小类型）范围大数据。
注意事项：一般不推荐使用，会使得数据丢失，精度损失。
int num2=60000000000L;
public class Main {
public static void main(String[] args) {
System.out.println("Hello World!");
int i=(int)600000000000L;//i=-1295421440
int j=(int )3.5;// 精度损失
System.out.println("i="+i);
}
}
//long----->int
int num=(int)100L;
运算符
算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
三元运算符
- 算术运算符的注意问题
• 如果对负数取模，可以把模数负号忽略不记，如： 5%-2=1。但被模
数是负数就另当别论。
• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时
，只保留整数部分而舍弃小数部分。
• 例如： int x=3510;x=x/1000*1000; x的结果是？
• “+”除字符串相加功能外，还能把非字符串转换成字符串 ，
• 例如： System.out.println(“5+5=”+5+5);//打印结果是？
我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：
赋值运算符
符号：
= , +=, -=, *=, /=, %=
示例：
int a,b,c; a=b=c =3;
int a = 3; a+=5;等同运算a=a+5;
思考：
short s = 3;
s=s+2; //编译器会报错
s+=2;// pass
有什么区别？
比较运算符
逻辑运算符
逻辑运算符用于连接布尔型表达式，在Java中不可以
写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别：
• 单&时，左边无论真假，右边都进行运算；
• 双&时，如果左边为真，右边参与运算，如果左边为假，那
么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。| 运算的两边只要有一个是true ,结果肯定是true.
异或( ^ )与或( | )的不同之处是：当左右都为true时，
boolean ret= true^ false; ret =true
ret=true ^ true ;//ret=false
结果为false。
位运算符
int i=9;//1001
i=i>>>1;//高位补 0 1001----> 0100 =4
int j=4;//高位补0
j=j>>>1;// 0100----->0010
位运算符
1.最有效率的方式算出2乘以8等于几？ 2<<3;
2.对两个整数变量的值进行互换(不需要第三
方变量)
int a=1,b=2;
a=a^b;
b=a^b;
a=a^b;
2.5.6 三元运算符
格式
• (条件表达式)?表达式1：表达式2；
• 如果条件为true，运算后的结果是表达式1；
• 如果条件为false，运算后的结果是表达式2；
示例：
• 获取两个数中大数。
• int x=3,y=4,z;
• z = (x>y)?x:y;//z变量存储的就是两个数的大数。
2.6 程序流程控制
判断结构
选择结构
循环结构
2.6.1 判断结构
if语句
三种格式：
- if(条件表达式)
{
执行语句；
} - if(条件表达式)
{
执行语句；
}
else
{
执行语句；
} - if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
if语句特点：
a,每一种格式都是单条语句。
b,第二种格式与三元运算符的区别：三元运算符运算
完要有值出现。好处是：可以写在其他表达式中。
c,条件表达式无论写成什么样子，只看最终的结构是
否是true 或者 false;
2.6.2 选择结构
switch语句
格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
……
default:
执行语句；
break；
}
2.6.2 选择结构
switch语句特点：
a,switch语句选择的类型只有四种： byte， short， int ， char。也可以 String
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执
行default。
c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下
执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
/**
* String 类型 也可用于switch
* Created by zengjx on 2019/4/19.
*/
public class Demo {
public static void main(String []args){
// test();
String s="abc";
switch (s){
case "abc":
System.out.println("abc");
break;
case "abb":
System.out.println("abb");
break;
}
}
输出结果：abc2.6.3 循环结构
while语句格式：
while(条件表达式)
{
执行语句；
}
do while语句格式：
do
{
执行语句；
}while(条件表达式);
do while特点是条件无论是否满足，
循环体至少被执行一次。
代表语句： while ， do while ， for
格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
for(int i=1;i<=5;i++){
for(int j=5-i;j>=0;j--){
System.out.print("*");
}
System.out.println();
}
for(int i=1;i<=5;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
输出：
*****
****
***
**
*
*
*
**
***
****
*****
for(int i=1;i<=5;i++){
for(int j=6-i;j>=1;j--){
System.out.print(j);
}
System.out.println();
}
54321
4321
321
21
1
for(int i=1;i<=5;i++){
for(int j=1;j<=i;j++){
System.out.print(i);
}
System.out.println();
}
1
22
333
4444
55555
打印9*9乘法表
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(i +" “+j+” ="+(i * j)+" ");
/*
- \n :回车
- \t: 制表符
- \b: 退格符
- \r: 按下回车键
/
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(i +""+j+"="+(i*j)+"\t");
}
System.out.print("\n");
}
}
* * * * *
- * * * *
-- * * *
--- * *
---- *
public class Main {
public static void main(String[] args) {
for(int i=1;i<=5;i++){
for( int z=1;z<i;z++){
System.out.print("-");
}
for(int j=i;j<=5;j++){
System.out.print(" *");
}
System.out.print("\n");
}
}
}
注：
a,for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，
为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，
重复找个过程，直到条件不满足为止。
b,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是
在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
c,最简单无限循环格式： while(true) , for(;?,无限循环存在的原因是并不知道循
环多少次，而是根据某些条件，来控制循环。
2.6.4 其他流程控制语句
说一下 break 和continue的区别？
break(跳出)， continue(继续)
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
注：
a,这两个语句离开应用范围，存在是没有意义的。
b,这个两个语句单独存在下面都不可以有语句，因为执行不到
。
c,continue语句是结束本次循环继续下次循环。
d,标号的出现，可以让这两个语句作用于指定的范围。
2.7 函数
2.7.1 函数的定义
什么是函数？
• 函数就是定义在类中的具有特定功能的一段独立小程序。
• 函数也称为方法。
函数的格式：
• 修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2， )
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。
注意：
• 函数中只能调用函数，不可以在函数内部定义函数。
• 定义函数时，函数的结果应该返回给调用者，交由调用者处 理
2.7.4 函数的重载(overload)
重载的概念在同一个类中，允许存在一个以上的同名函数， **只要它们的参数个数或者参数类型不
同即可。**重载的特点：与返回值类型无关，只看参数列表。重载的好处：方便于阅读，优化了程序设计。重载示例：//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}
2.8 数组
数组的定义
数组的内存分配及特点
数组操作常见问题
数组常见操作
数组中的数组
2.8.1 数组的定义
概念同一种类型数据的集合。其实数组就是一个容器。数组的好处可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例： int[] arr = new int5;
格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素， ……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
2.8.2 内存结构
内存划分
1.寄存器 2.本地方法区3.方法区4.栈内存5.堆内存
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空
间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内
存管理方式。
栈内存 用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存 数组和对象，通过new建立的实例都存放在堆内存中。其实数组就是对象。
每一个实体都有内存地址值
实体中的变量都有默认初始化值，根据类型不同
整型：0 ，小数 ： 0.0 或者 0.0f 或者 boolean :false
char:’\u0000’
arr 引用 堆内存的一个地址。
实体不在被使用，会在不确定的时间内被垃圾回收器回收方法区，本地方法区，寄存器
局部代码块：
public class Main {
public static void main(String[] args) {
{
int age =3;//局部代码块，限定局部变量生命周期
}
int[] arr =new int[3];
arr[0]=89;
System.out.println(arr[0]);
System.out.println(" age="+age);//不可用
}
}
2.8.3 数组操作常见问题
数组脚标越界异常(ArrayIndexOutOfBoundsException)int[] arr = new int2;
System.out.println(arr3);
访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。
2.8.4 数组常见操作
改变数组中某一项的值：
public class Main {
public static void main(String[] args) {
int[] arr=new int []{45,34,46,56,78};
int[] arr2={1,2,3,4};
test(arr);
System.out.println(" arr "+arr[2]);//由于数组传递的引用（地址）输出100
}
static void test(int[] arr){
arr[2]=100;
}
} 获取最值(最大值，最小值)
排序（选择排序，冒泡排序）
//选择排序: 每次选择出后面最大的跟当前数交换。
public static void selectSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp =arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
// 冒泡 ：相邻的比较
public static void bolbeSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1;j++){
if(arr[j]>arr[j+1]){
int temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}// 冒泡 ：相邻的比较
public static void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){//减1为了避免越界
// -i 是为了内循环参数与比较元素个数递减
if(arr[j]>arr[j+1]){
int temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}// 冒泡 ：相邻的比较
public static void bolbeSort2(int[] arr){
for(int i=arr.length-1;i>1;i++){
for(int j=0;j<i;j++){//减1为了避免越界
// -i 是为了内循环参数与比较元素个数递减
if(arr[j]>arr[j+1]){
int temp =arr[i];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
} 折半查找(二分查找) 前提：数组 有序
public static int halfSearch(int[] arr ,int key){
int min,max,mid;
if(arr==null ||arr.length==0){
return -1;
}
max=arr.length-1;
min=0;
mid=(max+min)/2;
while(arr[mid]!=key){
if(arr[mid]<key){
min=mid+1;
} else if(arr[mid]>key){
max=mid-1;
}
if(min>max){
return -1;
}
mid=(max+min)/2;
}
return arr[mid];
}获取一个整数数的16进制
//获取一个数的16进制表示形式
public static void toHex(int num) {
for(int i=0;i<8;i++){
int temp=num & 15;// 四位 1111 0---F
if(temp>9){
System.out.println((char)(temp-10+'A'));
}else{
System.out.println(temp);
}
num=num>>>4;
}
}
//获取一个数的16进制表示形式---查表法
public static void toHex1(int num) {
char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr =new char[8];
int pos=arr.length-1;
while(num!=0){
int temp=num & 15;
// System.out.println((char)(chs[temp]));
arr[pos--]=chs[temp];
num=num>>>4;
}
for(int i=pos+1;i<arr.length;i++){
System.out.println(" "+arr[i]);
}
}
10进制-转为2进制 8进制 16进制
//10进制---2进制 8进制 16进制
//trans(60,16,4);16进制
//trans(60,7,3);8进制
//trans(60,1,1);2进制
public static void trans(int num,int base,int offset) {
char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr =new char[32];
int pos=arr.length-1;
if(num==0){
System.out.println("0");
return;
}
while(num!=0){
int temp=num & base;
// System.out.println((char)(chs[temp]));
arr[pos--]=chs[temp];
num=num>>>offset;
}
for(int i=pos+1;i<arr.length;i++){
System.out.println(" "+arr[i]);
}
}2.8.5 数组中的数组
二维数组[][]
格式1： int[][] arr = new int3;
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr1, arr2
给第一个一维数组1脚标位赋值为78写法是： arr0 = 78；
**格式2： int[][] arr = new int3;***
二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int3;
arr1 = new int1;
arr2 = new int2;
2.8.5 数组中的数组
**格式3： int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};** 定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr1 = {2,7};
第三个一维数组 arr2 = {9,0,1,6};
第三个一维数组的长度表示方式： arr2.length;练习：获取arr数组中所有元素的和。使用for的嵌套循环即可。
注意特殊写法情况： int[] x,y[]; x是一维数组， y是二维数组。
面向对象
3.1 面向对象概念
3.1.1 理解面向对象
面向对象是相对面向过程而言
面向对象和面向过程都是一种思想
面向过程
• 强调的是功能行为
面向对象
• 将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。
3.1.2 面向对象的特点
是一种符合人们思考习惯的思想
可以将复杂的事情简单化
将程序员从执行者转换成了指挥者
完成需求时：
• 先要去找具有所需的功能的对象来用。
• 如果该对象不存在，那么创建一个具有所需功能的对象。
• 这样简化开发并提高复用。
面向对象的特征：
• 封装(encapsulation)
• 继承(inheritance)
• 多态(polymorphism)
3.2 类与对象的关系
类是具体事
物的抽象，概念上的定义。
对象即是该类事物实实在在存在的个体。
3.2.3 成员变量和局部变量的区别？
成员变量：
• 成员变量定义在类中，在整个类中都可以被访问。
• 成员变量随着对象的建立而建立，存在于对象所在的堆内
存中。
• 成员变量有默认初始化值。 ngdia）
局部变量：
• 局部变量只定义在局部范围内，如：函数内，语句内等。
• 局部变量存在于栈内存中。
• 作用的范围结束，变量空间会自动释放。
• 局部变量没有默认初始化值。
局部变量与类变量同名-----局部变量优先。
class Car{
String color ;
int num;//堆变量----有默认初始化
void show(){
System.out.println("color="+color+" num="+num);
}
void run(){
int num=10;///局部变量-----栈变量-没有默认--需要初始化
System.out.println("num="+num);
}
}
public class CarDemo {
public static void main(String[] args) {
Car c = new Car();//建立对象
c.color = "black";
c.num=4;
c.run();//输出 10
}类类型参数----传递引用
类类型一定指向对象或者为null
class Car{
String color;
int num=4;
void show(){
System.out.println("color="+color+" num="+num);
}
void run(){
int num=90;///局部变量
System.out.println("num="+num);
}
}
public class CarDemo {
public static void main(String[] args) {
Car c1 = new Car();//建立对象
Car c2 = new Car();//建立对象
show(c1);
show(c2);
System.out.println(" c1 "+"num= "+c1.num+"color="+c1.color);
System.out.println(" c2 "+"num= "+c2.num+"color="+c2.color);
}
public static void show(Car car){//类变量--引用
car.num=100;
car.color="blue";
}
输出结果：
c1 num= 100color=blue
c2 num= 100color=blue3.2.6 匿名对象
匿名对象是对象的简化形式
new Car;
匿名对象两种使用情况
• 当对对象方法仅进行一次调用的时
new Car（）.run（）；
new Car().num=5;// 0------->5
new Car.clolor=“green”;// null-------->“green”
//执行第二句的时候 num=5 已经被释放；
new Car().run();
• 匿名对象可以作为实际参数进行传递
show(new Car()）{
public static void show(Car car){//类变量–引用
car.num=100;
car.color=“blue”;
}
基本数据类型作为参数传递
int x=3;
public static void show(int x){
x=4;
}
3.3 封装
封装：是指隐藏对象的属性和实现细节，仅对外提供
公共访问方式。
好处：
• 将变化隔离。
• 便于使用。
• 提高重用性。
• 提高安全性。
封装原则：
• 将不需要对外提供的内容都隐藏起来。
• 把属性都隐藏，提供公共方法对其访问。
3.4 构造函数
特点：
1. 函数名与类名相同
2. 不用定义返回值类型
3. 不可以写return语句
作用：
给对象进行初始化。
注意：
4. 默认构造函数的特点。
5. 多个构造函数是以重载的形式存在的。
Person()
Person(String name,int age)
Person(int age，String name)
6. 默认构造函数：
一个类中默认会有一个空参数的构造函数，
这个默认的构造函数的权限和所属类一致。
如果类被public修饰，那么默认的构造函数也带public修饰符。
如果类没有被public修饰，那么默认的构造函数，也没有public修饰。
默认构造构造函数的权限是随着的类的变化而变化的。
一个类中
如果没有定义过构造函数，那么会包含一个默认的空参数的构造函数。如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
一般函数与构造函数的区别：
构造函数对象创建时就被调用，一般函数对象创建后，需要该函数功能时调用。
构造函数：对象创建时，会调用一次。
一般函数：对象创建后，可以调用多次。
什么时候定义构造函数？
在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。
class Person
{
private Person(){}// 空参数 构造
private String name = "hah";
private int age;
private static String country = "cn";
**Person(String name,int age)**//带参构造函数
{
this.name = name;
this.age = age;
}
{
System.out.println(name+".."+age);
}
public void setName(String name)
{
this.name = name;
}
public void speak()
{
System.out.println(this.name+"..."+this.age);
}
public static void showCountry()
{
System.out.println("country="+Person.country);
Person.method();
}
public static void method()
{
System.out.println("method run");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person(“zhangsan”,20);
p.setName(“lisi”);
new Person();
}
}
/*
Person p = new Person(“zhangsan”,20);
该句话都做了什么事情？
1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址付给栈内存中的p变量。
*/
构造函数 调用构造函数：
Person(String name){
this.name=name;
}
Person(String name,int age){
this(name);//调用 Person(String name) 对this调用必须是构造函数调用的第一条语句。
this.speak();
this.age=age;
}
1.构造函数Person(String name ,int age) 进栈
2.构造Person(String name) 进栈
3.构造Person(String name) 出栈
4.堆内对象赋值
5.构造函数Person(String name ,int age) 出栈
对象初始化过程：构造函数进栈
3.4.1 private(私有)关键字
private关键字：
• 是一个权限修饰符。
• 用于修饰成员(成员变量和成员函数)
• 被私有化的成员只在本类中有效。
常用之一：
• 将成员变量私有化，对外提供对应的set ， get
方法对其进行访问。提高对数据访问的安全
性。
构造函数特点
- 函数名与类名相同
- 不用定义返回值类型
- 不可以写return语句
作用：
给对象进行初始化。
注意： - 默认构造函数的特点。
- 多个构造函数是以重载的形式存在的
3.5 this关键字
this 代表本对象的引用。
什么时候使用this关键字呢？
当在函数内需要用到调用该函数的对象时，就用this。
类内部函数调用该函数的对象时，但是本类功能内部使用了本类对象，都用 this 表示。
注意 ：用于构造函数之间的调用 ，this语句 调用构造函数必须在构造函数的第一句；
（初始化）否则编译不通过。
构造递归调用会导致栈溢出：（没有构造函数出栈）
3.6 static关键字
static关键字：
• 用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用
使用注意
静态方法只能访问静态成员
静态方法中不可以写this， super关键字
主函数是静态的
/*
什么使用静态？
要从两方面下手：
因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
静态变量与成员变量区别？
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3，别名不同。
成员变量也称为实例变量。
静态变量称为类变量。
4，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.
静态使用的注意事项：
1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2，静态方法中不可以使用this或者super关键字。
3，主函数是静态的。
4.静态变量调用：1.对象调用 2.类名. 静态变量
什么时候定义静态函数呢？
当功能内部没有访问到肺静态数据(对象的特有数据)，
那么该功能可以定义成静态的。
*/
class Person
{
String name;
static String country = “cn”;
public static void show()
{
System.out.println(contry+“haha”);
}
}
class
{
public static void main(String[] args)
{
Person p = new Person();
p.show();
//Person .show();
}
}
静态代码块
class Person
{
static String country="CN";
private String name;
static int num;
{//构造代码块。可以给所有对象进行初始化
System.out.println("Person 构造代码块 ");
// cry();
}
static
{
num=10;
System.out.println("Person 静态代码块");
}
Person()//是给对应的对象进行针对性的初始化。
{
name = "baby";
System.out.println("Person 无参构造函数");
// cry();
}
Person(String name)
{
this.name = name;
System.out.println("Person 带参构造函数Person(String name)");
// cry();
}
public void cry()
{
System.out.println("哇哇");
}
public void speak()
{
System.out.println("name:"+name);
}
static void show()
{
System.out.println("show run");
}
}
public class StaticCodeDemo {
static {
System.out.println("StaticCodeDemo 静态代码块");
}
public static void main(String[] args){
Person p =null;//StaticCodeDemo 静态代码块
p=new Person();//Person 静态代码块 ---Person 构造代码块 -- Person 无参构造函数
System.out.println("类名调用静态变量："+Person.country);
System.out.println("对象调用静态变量："+p.country);
}
}
final：最终 作为一个修饰符
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3，被final修饰的方法不可以被复写。
4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。
而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。
单词间通过_连接。
5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
3.7 单例设计模式
4 继承
4.1 继承的概述
通过 extends 关键字让类与类之间产生继承关系。
• class SubDemo extends Demo{}
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
4.2 继承的特点
继承：
1，提高了代码的复用性。
2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。
Java只支持单继承，不支持多继承。
• 一个类只能有一个父类，不可以有多个父类。
• class SubDemo extends Demo{} //ok
• class SubDemo extends Demo1,Demo2…//error
Java支持多层继承(继承体系)
• class A{}
• class B extends A{}
• class C extends B{}
定义继承需要注意：
• 不要仅为了获取其他类中某个功能而去继承
• 类与类之间要有所属( " is a " )关系， xx1是xx2的一种。
4.3 super关键字
super ：代表父类引用
this :代表本类引用
当子父类出现变量重名可以使用super 来区分
子类要调用父类构造函数时，可以使用super关键字。
4.4 函数覆盖
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重
写或者复写。
父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名
获取。
覆盖注意事项：
• 覆盖时，子类方法权限一定要大于等于父类方法权限
• 静态只能覆盖静态。
覆盖的应用：
• 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写
父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内
容。
4.5 子类的实例化过程
子类中所有的构造函数默认都会访问父类中空参数的
构造函数
因为每一个构造函数的第一行都有一条默认的语句
super();
子类会具备父类中的数据，所以要先明确父类是如何
对这些数据初始化的。
当父类中没有空参数的构造函数时，子类的构造函数
必须通过this或者super语句指定要访问的构造函数。
3，子父类中的构造函数。
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
子类的实例化过程。：
结论：
子类的所有的构造函数，默认都会访问父类中【空参数的构造函数】。
因为子类每一个构造函数内的第一行都有一句隐式【super();】
【this()】代表本类构造函数
构造函数 不能覆盖 构造函数不继承
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
class Fu //extends Object
{
int num ;
Fu()
{
//super();
num= 60;
System.out.println("父类无参构造");
}
Fu(int x)
{
System.out.println("父类带参构造"+x);
}
}
lass Zi extends Fu
{
Zi()
{
super();
//super(4); 带参数
System.out.println("子类构造");
}
Zi(int x)
{
this();//调用本类无参构造
//super();//调用父类带参构造。
//super(3);//调用带参父类构造
System.out.println("zi..."+x);
}
}
class ExtendsDemo4
{
public static void main(String[] args)
{
Zi z = new Zi(0);//
System.out.println(z.num);
}
}4.6 final关键字
final可以修饰类，方法，变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量。
4.7 抽象类
4.7.1 抽象类概述
抽象定义：
• 抽象就是从多个事物中将共性的，本质的内容抽取出来。
• 例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。
抽象类：
• Java中可以定义没有方法体的方法，该方法的具体实现由子类完
成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
抽象方法的由来：
• 多个对象都具备相同的功能，但是功能具体内容有所不同，那么在
抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功
能声明，没有功能主体的方法称为抽象方法。
• 例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽
象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。
4.7.2 抽象类有哪些的特点？
抽象类和抽象方法必须用abstract关键字来修饰。
抽象类不一定必须含有抽象方法
抽象方法只有方法声明，没有方法体，定义在抽象类中。
• 格式： 修饰符 abstract 返回值类型 函数名(参数列表) ;
抽象类不可以被实例化，也就是不可以用new创建对象。原因如
下：
• 抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实
例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
• 而且抽象类即使创建了对象，调用抽象方法也没有意义。
抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象
方法后才可以创建对象，否则该子类也是抽象类。
4.7.3 抽象类举例代码讲解
4.7.4 抽象类相关问题
**抽象类中是否有构造函数？
有 ，抽象类一个父类，要给子类提供实例的初始化。
抽象关键字abstract不可以和哪些关键字
共存？
final: 被final 修饰不能有子类，而被abstract修饰的类一定是一个父类。
private :抽象类如果有私有的抽象方法。不被子类所知，就无法被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。
可是抽象方法运行没意义。
抽象类中可不可以没有抽象方法？**
*抽象类可以不包含抽象方法，包含抽象方法的类一定是抽象类。
抽象类里面可以有非抽象方法？
抽象类里面可以有非抽象方法
但接口里只能有抽象方法*
获取系统时间
/*
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。
获取时间：System.currentTimeMillis();
当代码完成优化后，就可以解决这类问题。
这种方式，模版方法设计模式。
什么是模版方法呢？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，
那么这时就将不确定的部分暴露出去。由该类的子类去完成。
*/
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runcode();//调用抽象方法
long end = System.currentTimeMillis();
System.out.println("毫秒："+(end-start));
}
public abstract void runcode();
}
class SubTime extends GetTime
{
public void runcode()
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}
class TemplateDemo
{
public static void main(String[] args)
{
//GetTime gt = new GetTime();
SubTime gt = new SubTime();
gt.getTime();
}
}4.8 接口
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口。
接口定义时，格式特点：
1，接口中常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
格式：
interface {}
接口中的成员修饰符是固定的。
•成员常量： public static final
•成员函数： public abstract
接口的出现将“多继承”通过另一种形式体现出
来，即“多实现”。
interface Inter
{
public static final int NUM = 3;
public abstract void show();
}
interface InterA
{
public abstract void show();
}
class Demo
{
public void function(){}
}
class Test extends Demo implements Inter,InterA
{
public void show(){}
}
4.8.1 接口的特点
接口是对外暴露的规则。
接口是程序的功能扩展。
接口可以用来多实现。
类与接口之间是实现关系，而且类可以
继承一个类的同时实现多个接口。
接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误），并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。
接口与接口之间可以有继承关系。
接口 示例
4.9 多态
定义：某一类事物的多种存在形态。
例：动物中猫，狗。
猫这个对象对应的类型是猫类型
• 猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为
动物。
• 动物 y = new 猫();
• 动物是猫和狗具体事物中抽取出来的父类型。
• 父类型引用指向了子类对象。
体现：
父类或者接口的引用指向或者接收自己的子类对象。
作用：
多态的存在提高了程序的扩展性和后期可维护性
前提：
• 需要存在继承或者实现关系
• 要有覆盖操作
abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨头");
}
public void kanJia()
{
System.out.println("看家");
}
}
class Pig extends Animal
{
public void eat()
{
System.out.println("饲料");
}
public void gongDi()
{
System.out.println("拱地");
}
}
//-----------------------------------------
class DuoTaiDemo
{
public static void main(String[] args)
{
//Cat c = new Cat();
//c.eat();//吃鱼
//Dog d = new Dog();
//d.eat();
//Cat c = new Cat();
/*
Cat c1 = new Cat();
function(c1);
function(new Dog());
function(new Pig());
*/
//Animal c = new Cat();
//c.eat();
function(new Cat());// 吃鱼
function(new Dog());// 吃骨头
function(new Pig()); // 饲料
}
public static void function(Animal a)//Animal a = new Cat(); 父类引用指向子类对象
{
a.eat();
//a.catchMouse();
}
/*
public static void function(Cat c)//
{
c.eat();
}
public static void function(Dog d)
{
d.eat();
}
public static void function(Pig p)
{
p.eat();
}
*/
}
4.9.2 多态的特点
4.9.1
成员函数：
• 编译时：要查看引用变量所属的类中是否有所
调用的成员。
• 在运行时：要查看对象所属的类中是否有所调
用的成员。
成员变量：
• 只看引用变量所属的类。
内部类
将一个类定义在另一个类的里面，对里面那个
类就称为内部类（内置类，嵌套类）。
访问特点：
• 内部类可以直接访问外部类中的成员，包括私有成
员。
• 而外部类要访问内部类中的成员必须要建立内部类
的对象。
内部类的位置
内部类定义在成员位置上
• 可以被private static成员修饰符修饰。
• 被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上
• 也可以直接访问外部类中的成员。
• 同时可以访问所在局部中的局部变量，但必须是被final修
饰的。
4.10匿名内部类
4.11 异常
4.11.1 Throwable 中的方法
4.11.2 throws 和throw
4.11.3异常处理
4.11.4自定义异常
4.11.5 异常细节
4.12包（package）
4.12.1 classpath
4.12.2包之间的访问
4.13 * 四种权限
4.14 import
4.15 jar 包
4.15.1 jar 包的操作
通过jar.exe工具对jar的操作。
• 创建jar包
• jar -cvf mypack.jar packa packb
• 查看jar包
• jar -tvf mypack.jar [>定向文件]
• 解压缩
• jar -xvf mypack.jar
• 自定义jar包的清单文件
• jar –cvfm mypack.jar mf.txt packa packb
IO 流
字符流—创建文件
创建流对象，建立数据存放文件
• FileWriter fw = new FileWriter(“Test.txt”);
调用流对象的写入方法，将数据写入流
• fw.write(“text”);
关闭流资源，并将流中的数据清空到文件中。
• fw.close();
不写close方法会有什么结果呢？
如果想在原有文件上继续加入新的数据呢？
public static void fileDemo(){
FileWriter fw = null;
try{
fw= new FileWriter("text.txt");
fw.write("test");
}catch (IOException e){
System.out.println(e.toString());
}finally {
if(fw!=null){
try{
fw.close();
}catch (IOException e){
System.out.println(e.toString());
}
}
}
}文件创建结果：
字符流——读取文件
建立一个流对象，将已存在的一个文件加载进
流。
• FileReader fr = new FileReader(“Test.txt”);
创建一个临时存放数据的数组。
• char[] ch = new char[1024];
调用流对象的读取方法将流中的数据读入到数组
中。
• fr.read(ch);
思考：
• 在加载文件时候是否是将文件全部加载进流
• 为什么定义数组，要定义多大呢？
public static void fileReader() {
FileReader fr = null;
try {
fr = new FileReader("F:\\JavaDemo\\text.txt");
char[] data = new char[1024];
int len = 0;
if ((len = fr.read(data)) != -1) {
System.out.print(" data=" + new String(data, 0, len));
}
fr.read();
} catch (FileNotFoundException e) {
// e.toString()
System.out.println(e.toString());
} catch (IOException e) {
System.out.println(e.toString());
} finally {
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}
}
}文件读取结果：
注意：
定义文件路径时，可以用“/”或者“\”。
在创建一个文件时，如果目录下有同名文
件将被覆盖。
在读取文件时，必须保证该文件已存在，
否则出异常。
练习： Copy一个文本文件。
字符流的缓冲区
缓冲区的出现提高了对数据的读写效率。
对应类
• BufferedWriter
• BufferedReader
缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强。
装饰设计模式
对原有类进行了功能的改变，增强。
装饰模式的基本格式。
它与继承有什么不同？
了解BufferedReader的原理。
练习：
• 模拟一个BufferedReader类。
• 模拟一个LineNumberReader类。
字节流
基本操作与字符流类相同
但它不仅可以操作字符，还可以操作其他
媒体文件
例程
• Copy一个Jpg文件。
字节流的缓冲区
同样是提高了字节流的读写效率。
练习：
• 通过几种方式对MP3的进行拷贝，比较它们的
效率。
模拟一个BufferedInputStream
转换流
InputStreamReader,OutputStreamWriter
转换流的由来
• 字符流与字节流之间的桥梁
• 方便了字符流与字节流之间的操作
转换流的应用
• 字节流中的数据都是字符时，转成字符流操作
更高效。
例程：标准输入输出。
标准输入输出流
System类中的字段： in， out。
它们各代表了系统标准的输入和输出设备。
默认输入设备是键盘，输出设备是显示器。
System.in的类型是InputStream.
System.out的类型是PrintStream是
OutputStream的子类FilterOutputStream 的子
类.
标准输入输出流示例
例:获取键盘录入数据，然后将数据流向显示器，那么显示器就是目
的地。
通过System类的setIn， setOut方法对默认设备进行改变。
• System.setIn(new FileInputStream(“1.txt”));//将源改成文件1.txt。
• System.setOut(new FileOutputStream(“2.txt”));//将目的改成文件2.txt
因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。
BfferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw =
new BufferedWriter(new OutputStreamWriter(System.out));
加粗样式
全新的界面设计 ，将会带来全新的写作体验；
- 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
- 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
- 全新的 KaTeX数学公式 语法；
- 增加了支持甘特图的mermaid语法1 功能；
- 增加了 多屏幕编辑 Markdown文章功能；
- 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
- 增加了 检查列表 功能。
功能快捷键
撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
合理的创建标题，有助于目录的生成
直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。
如何改变文本的样式
强调文本 强调文本
加粗文本 加粗文本
标记文本
删除文本
删除
引用文本
引用
H2O is是液体。
HHHH
210 运算结果是 1024.
插入链接与图片
链接: link.
图片: 
带尺寸的图片:
居中的图片: 
居中并且带尺寸的图片:
当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。
如何插入一段漂亮的代码片
去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.
生成一个适合你的列表
- 项目
- 项目
- 项目
- 项目
- 项目1
- 项目2
- 项目3
- 计划任务
- 完成任务
创建一个表格
一个简单的表格是这么创建的：
| 项目 | Value |
|---|---|
| 电脑 | $1600 |
| 手机 | $12 |
| 导管 | $1 |
设定内容居中、居左、居右
使用:---------:居中
使用:----------居左
使用----------:居右
| 第一列 | 第二列 | 第三列 |
|---|---|---|
| 第一列文本居中 | 第二列文本居右 | 第三列文本居左 |
|:-----------? -------------?:-------------|
| 第一列文本居中 | 第二列文本居右 | 第三列文本居左 |
SmartyPants
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：
| TYPE | ASCII | HTML |
|---|---|---|
| Single backticks | 'Isn't this fun?' | ‘Isn’t this fun?’ |
| Quotes | "Isn't this fun?" | “Isn’t this fun?” |
| Dashes | -- is en-dash, --- is em-dash | – is en-dash, — is em-dash |
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：
| TYPE | ASCII | HTML |
|---|---|---|
| Single backticks | 'Isn't this fun?' | ‘Isn’t this fun?’ |
| Quotes | "Isn't this fun?" | “Isn’t this fun?” |
| Dashes | -- is en-dash, --- is em-dash | – is en-dash, — is em-dash |
创建一个自定义列表
-
Markdown
- Text-to- HTML conversion tool Authors
- John
- Luke
如何创建一个注脚
一个具有注脚的文本。2
注释也是必不可少的
Markdown将文本转换为 HTML。
KaTeX数学公式
您可以使用渲染LaTeX数学表达式 KaTeX:
Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N 是通过欧拉积分
Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t   . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt.
你可以找到更多关于的信息 LaTeX 数学表达式here.
新的甘特图功能，丰富你的文章
- 关于 甘特图 语法，参考 这儿,
UML 图表
可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：:
这将产生一个流程图。:
- 关于 Mermaid 语法，参考 这儿,
FLowchart流程图
我们依旧会支持flowchart的流程图：
- 关于 Flowchart流程图 语法，参考 这儿.
导出与导入
导出
如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。
导入
如果你想加载一篇你写过的.md文件或者.html文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。
欢迎使用马克飞象
##nan
@(示例笔记www本)[马克飞象|帮助|Markdown]
马克飞象是一款专为印象笔记（Evernote）打造的Markdown编辑器，通过精心的设计与技术实现，配合印象笔记强大的存储和同步功能，带来前所未有的书写体验。特点概述：
- 功能丰富 ：支持高亮代码块、LaTeX 公式、流程图，本地图片以及附件上传，甚至截图粘贴，工作学习好帮手；
- 得心应手 ：简洁高效的编辑器，提供桌面客户端以及离线Chrome App，支持移动端 Web；
- 深度整合 ：支持选择笔记本和添加标签，支持从印象笔记跳转编辑，轻松管理。
文章目录
- 基础语法
- 第一个java 程序各个变量的解释
- 标识符
- 关键字
- java注释
- 常量 变量
- 运算符
- 2.7 函数
- 2.8 数组
- 面向对象
- 4 继承
- IO 流
- 功能快捷键
- 合理的创建标题，有助于目录的生成
- 如何改变文本的样式
- 插入链接与图片
- 如何插入一段漂亮的代码片
- 生成一个适合你的列表
- 创建一个表格
- 创建一个自定义列表
- 如何创建一个注脚
- 注释也是必不可少的
- KaTeX数学公式
- 新的甘特图功能，丰富你的文章
- UML 图表
- FLowchart流程图
- 导出与导入
- 欢迎使用马克飞象
Markdown简介
Markdown 是一种轻量级标记语言，它允许人们使用易读易写的纯文本格式编写文档，然后转换成格式丰富的HTML页面。 —— 维基百科
正如您在阅读的这份文档，它使用简单的符号标识不同的标题，将某些文字标记为粗体或者斜体，创建一个链接或一个脚注3。下面列举了几个高级功能，更多语法请按Ctrl + /查看帮助。
代码块
@requires_authorization
def somefunc(param1='', param2=0):
'''A docstring'''
if param1 > param2: # interesting
print 'Greater'
return (param2 - param1 + 1) or None
class SomeClass:
pass
>>> message = '''interpreter
... prompt'''LaTeX 公式
可以创建行内公式，例如 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N。或者块级公式：
x = − b ± b 2 − 4 a c 2 a x = \dfrac{-b \pm \sqrt{b^2 - 4ac}}{2a} x=2a−b±b2−4ac
表格
| Item | Value | Qty |
|---|---|---|
| Computer | 1600 USD | 5 |
| Phone | 12 USD | 12 |
| Pipe | 1 USD | 234 |
流程图
以及时序图:
复选框
使用 - [ ] 和 - [x] 语法可以创建复选框，实现 todo-list 等功能。例如：
- 已完成事项
- 未完成
- 待办事项1
- 待办事项2
- 复选框
注意：目前支持尚不完全，在印象笔记中勾选复选框是无效、不能同步的，所以必须在马克飞象中修改 Markdown 原文才可生效。下个版本将会全面支持。
印象笔记相关
笔记本和标签
马克飞象增加了@(笔记本)[标签A|标签B]语法, 以选择笔记本和添加标签。 绑定账号后， 输入(自动会出现笔记本列表，请从中选择。
笔记标题
马克飞象会自动使用文档内出现的第一个标题作为笔记标题。例如本文，就是第一行的 欢迎使用马克飞象。
快捷编辑
保存在印象笔记中的笔记，右上角会有一个红色的编辑按钮，点击后会回到马克飞象中打开并编辑该笔记。
**注意：**目前用户在印象笔记中单方面做的任何修改，马克飞象是无法自动感知和更新的。所以请务必回到马克飞象编辑。
数据同步
马克飞象通过将Markdown原文以隐藏内容保存在笔记中的精妙设计，实现了对Markdown的存储和再次编辑。既解决了其他产品只是单向导出HTML的单薄，又规避了服务端存储Markdown带来的隐私安全问题。这样，服务端仅作为对印象笔记 API调用和数据转换之用。
隐私声明：用户所有的笔记数据，均保存在印象笔记中。马克飞象不存储用户的任何笔记数据。
离线存储
马克飞象使用浏览器离线存储将内容实时保存在本地，不必担心网络断掉或浏览器崩溃。为了节省空间和避免冲突，已同步至印象笔记并且不再修改的笔记将删除部分本地缓存，不过依然可以随时通过文档管理打开。
**注意：**虽然浏览器存储大部分时候都比较可靠，但印象笔记作为专业云存储，更值得信赖。以防万一，请务必经常及时同步到印象笔记。
编辑器相关
设置
右侧系统菜单（快捷键Ctrl + M）的设置中，提供了界面字体、字号、自定义CSS、vim/emacs 键盘模式等高级选项。
快捷键
帮助 Ctrl + /
同步文档 Ctrl + S
创建文档 Ctrl + Alt + N
最大化编辑器 Ctrl + Enter
预览文档 Ctrl + Alt + Enter
文档管理 Ctrl + O
系统菜单 Ctrl + M
加粗 Ctrl + B
插入图片 Ctrl + G
插入链接 Ctrl + L
提升标题 Ctrl + H
关于收费
马克飞象为新用户提供 10 天的试用期，试用期过后需要续费才能继续使用。未购买或者未及时续费，将不能同步新的笔记。之前保存过的笔记依然可以编辑。
反馈与建议
感谢阅读这份帮助文档。请点击右上角，绑定印象笔记账号，开启全新的记录与分享体验吧。
注脚的解释 ↩︎
这是一个示例脚注。请查阅 MultiMarkdown 文档 关于脚注的说明。 限制： 印象笔记的笔记内容使用 ENML 格式，基于 HTML，但是不支持某些标签和属性，例如id，这就导致
脚注和TOC无法正常点击。 ↩︎
331
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
