对应的学习视频地址 1，源代码程序名：HelloWorld.java （第一行 第三个单词一定与文件名相同） 2, 编译命令javac C:\Users\shiyihao\Desktop>javac HelloWorld.java （产生.class文件） 3, 运行 C:\Users\shiyihao\Desktop>java HelloWorld

4，注释 //：单行注释（可以写在第一行末尾）

/* */： 多行注释（区块注释）

5，关键字：小写 标识符：英文字母，数字，$, 与 _ 不能以数字开头

大驼峰与小驼峰规则

6，常量：“123”，123，12.3， ‘a’,‘中’， true, false , null

注：单引号间必须有且只有一个字符

7，数据类型 byte【-128，127】

system.out.println(100L) 以long数据类型输出

8，变量的使用与C语言相同

注：大括号内定义的变量只能在大括号中使用

int a,b,c; a=1;b=2;c=3 int a=1,b=2,c=3; long num1=100L (100)

9,数据类型转换（boolean类型不能转换） 自动类型转换：从小到大的规则 强制类型转换：int num=100L (错误) int num=(int)100L (正确)

注意：int 只有32位；int 直接舍弃小数位；计算时会先变成int类型（用int接受）

10，notepade ++ 打开文件命令行 快速启动

11, char a=‘1’; System.out.println(a+0); 查看ASCll 码(unicode 码) int b=a; System.out.println(b+0);

12，加法在字符串中的运用

13，后自增变化迟缓（先用后加）

14，逻辑运算具有短路效果

15，三元运算 int max=a>b ?a:b; 结果必须使用。

1，方法：将一个功能抽取出来

定义一个方法： public static void 方法名称(){ 方法体 }

例： public static void farmer(){ Sysrem.out.println(“浇水”)； Sysrem.out.println(“浇水”)； } 方法定义不能产生嵌套包含关系。

调用方法：

方法名称();

例： public class HelloWorld{ public static void main (String[] args){

farmer(); } public static void farmer(){ System.out.println("浇水"); System.out.println("施肥"); }

}

2，jdk 的jshell 使用 直接输入 jshell 命令； /exit 退出； 表达式编译器直接优化运算；

3，判断语句 (1) if (条件){语句体 }; (2) if (条件){语句体 }；else{语句体2}； (3) if (条件){语句体 }；else if (条件2){语句体3}；else{语句体2}；

switch(条件) case 常量1:语句体1；break; case 常量2:语句体2；break; default: 语句体1；break; 4.循环语句 for (初始化；布尔表达式；步进表达式){ 语句 }

while (条件判断){ 循环体; }

do { 语句; }while () ;

break 打断循环； continue 跳过循环；

CTRL + c 强制停止循环；

5，IDEA软件 项目->模块->包->文件；

empty project->(点两下src出现)->add（加号）->new module->src(new pagkage) 注：pagkage中的点起到文件分隔的作用

创建多层文件夹

->new java.class

6.IDEA使用 public static void main(String[] args) {

}==psvm;

System.out.println();==sout;

鼠标右键 run运行

alt+4 弹出输出窗口

alt +shift +F10 快捷键运行

7.idea 基本配置

（1）file -settings-editor-font(调整字体) （2）fire-settings-keymap(调整快捷键) main menu-code-completion-basic(自动补全)：alt+/ alt+enter ： 错误修复 ctrl+y: 删除光标所在行 ctrl+d: 重复光标所在行 CTRL+alt+l: 格式化 ctrl+/: 添加，取消一行注释 ctrl+shift+/: 多行注释 alt+ins: 自动生成代码 alt+shift+上下箭头：单行上下移动 8.file-new-mode… 添加新模板 file-project structure-+ 导入模板

5.fori=for(int i=0; i<5; i++)

注意 print与println的不同

方法格式： 修饰符 返回值类型 方法名称（参数类型 参数名称 ，。。。）{ 方法体 return 返回值； } 11，方法调用

12，方法重载 相同名称+不同参数列表

13，shift+F6 方法输入名称与输出名称同时改变

14，数组 动态数组创建：int[] arrayA = new int[300]; 静态数组创建：int[] arrayB = new int[]{5,15,20}; 省略格式：int[] arrayC = {1,2,3}; 列表创建可以拆分（省略格式不能） 访问数组元素： System.out.println(arrayA[0]); int[] arrayC=null:不能访问

获取数组长度： int len =arrayB.length 运用new 相当于创建新数组地址

颠倒数组：for (int min = 0,max=arrayB.length-1; min<max;min++,max–) { int temp=arrayA[min]; arrayA[min]=arrayA[max]; arrayA[max]=temp;

数组作为参数传递 int[] array (地址)

作为返回值 public static int[] a(int a,int b, int c)

1，面向对象 System.out.println(Arrays.toString(arrayB)); 输出列表 类与对象关系

（1）类的定义（属性（成员变量）+行为（成员方法））

注意成员方法不要写static关键字； public class Students { String name; int age; public void eat(){ System.out.println(“吃饭”); } public void sleep(){ System.out.println(“睡觉”); } }

调用 public class DemoStudent { public static void main(String[] args) { Students stu=new Students(); System.out.println(stu.name); stu.age=18; System.out.println(stu.age); stu.eat(); } }

类也可以传递到函数中去（地址） 也可以作为返回值。

2，面向对象的封装性

方法是一种封装

private 也是一种封装

private int age;

private 修饰的变量不能在类以外进行访问 只能通过类中定义的函数访问

3，this关键字运用

public class Person { String name; public void sayHello(String name){ System.out.println(name+ " "+name); } }

public class DemoPerson { public static void main(String[] args) { Person person=new Person(); person.name=“a”; person.sayHello(“b”);

}

}

当方法的局部变量与类的成员变量重名时，依照就近原则

如果需要访问本类中的成员变量，需要使用 this.成员变量名：成员变量（在类的定义中使用） 通过谁调用方法谁就是this

4,构造方法用于创建对象 public 类名称（参数类型 参数名称）{ 方法体 } 名称与类名一致且不需要返回值（连void 都不需要）

通过new 调用 如果未编写构造方法，编译器回默认构造一个空构造方法

构造方法只有一个（可以进行重载：全参+无参）

标准类：Java Bean

code-generate(alt+insert)-getter and setter(按shift全选)/constructor(生成构造函数)

5，API的使用

导包+创建+使用 只有java.long 包下内容不需要导包

import java.util.Scanner;

Scanner sc = new Scanner(System.in);

int num=sc.nextInt(); String str=sc.next();

6.匿名对象的使用 new Person().name=“a” 匿名对象只能使用一次

快捷键alt+enter 推荐变量名

匿名对象作为方法的参数与返回值

import java.util.Scanner;

public class Demo01Anonymous { public static void main(String[] args){ //methodParam(new Scanner(System.in)); Scanner sc= methodReturn(); int num =sc.nextInt(); System.out.println("输入 ： "+num); }

public static void methodParam(Scanner sc) { int num = sc.nextInt(); System.out.println("输入 ： "+num); } public static Scanner methodReturn(){ return new Scanner(System.in); }

}

7.Random的使用 [0,输入的整数)；

import java.util.Random; public class Demo01Random { public static void main(String[] args) { Random r=new Random(); int num=r.nextInt(); System.out.println(num); } }

8.创建对象数组（集合） ArrayList 运用 <泛型>：只能是引用类型，高级jdk 右边泛型可以不写 ArrayList ListA =new ArrayList<>(); 输出得到的是列表内容 list.add(“A”)；，boolean success=list.add(“A”)；： 添加元素； String name=list.get(2); String remove=list.remove(1); int size=list.size(); list.fori：快捷遍历集合 for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); }

基本类型 包装类 byte Byet short Short int Integer float Float double Double char Character boolean Boolean

自动拆箱 自动装箱 Integer total = 99; int totalprim = total;

作为方法参数：Arraylist list 作为方法返回值：Arraylist

9.字符串 就算没有new，程序中所有双引号字符串都是String类的对象 内容不可改变，所以可以共享使用 效果上是char[],实际上是byte[]字节数组

创建字符串 public String(); public String(char[] array); public String(byte[] array); String str=“Hello”

String str3= new String(charArray);

按住Ctrl键不松手可以查看类的源代码。

字符串常量池 new的对象不在池中

引用对象相等指的是地址值相等

public boolean equals(Object obj);

Object 可以接收任何对象

boolean result1 =str1.equals(str2); boolean result2 =str1.equals(“Hello”); 不推荐 当引用对象为null时报 NullPointException boolean result3 =“Hello”.equals(str1)； 推荐

public boolean equalsIngnoreCase(Object obj); //忽略大小写比较

public int leagth() :获取字符串长度 public String concat(String str) :返回拼接后的字符串 public char charAt(int index) :获取指定索引位置的单个字符 public int indexOf(String str) :索引子字符串开始位置 若没有则返回-1

截取方法 public String substring(int index); public String substring(int index,int end); :最后一个不包含

字符串的转换方法

public char[] toCharArray(); 将字符串拆分为字符数组 public byte[] getBytes(); 将字符串拆分为字节数组 public String replace(CharSequence oldString, CharSequence newString) 将老字符串替换为新字符串

Ctrl 加字母n 打开任意一个类

字符串的分割方法

public String [] split(String regex); 按照规则切分（英文句点必须写成"\."才能切分）正则表达式

Alt + 回车 自动添加返回值 String str1=“aaa,bbb,ccc”; String[] split = str1.split(",");

10.static 关键字 static 修饰成员对象 private static int idCounter=0;

static 修饰的方法称为静态方法、无static 的称为成员方法 如果没有static 那么必须首先创建对象

无static: MyClass obj = new Myclass(); obj.method;

有static: obj.methodStatic(); //不推荐 MyClass.methodStatic();// 推荐

有static 也可以通过类名称调用成员变量

对于本类当中的静态方法，可以省略类名称

注意：1.静态方法不能直接访问非静态成员变量 2.静态方法不能使用this .

静态代码块只能（在首次用到本类时）唯一的执行一次：用以一次性的为静态成员变量赋值。

public class 类名称{ static{ //静态代码块内容 } }

11.数组工具Arrays import java.util.Arrays;

public static String toString(数组)：将参数数组变成字符串 int [] intArray ={10,20,30}; String intStr =Array.toString(intArray);

public static void sort(数组)： 按照默认升序对数组元素进行排序（数字在字母前）// 自定义类型需要Comparable or Comparator接口支持

chars.fori：正序； chars.fort: 倒序；

12.数学工具Math Math.abs(num): 绝对值 Math.ecil(num):向上取整 Math.floor(num):向下取整 Math.round(num):四舍五入

13.继承 共性抽取 父类 子类 父类名称不变 子类： public class 子类名称 extends 父类名称{}

如果父子中成员变量重名，等号左边是谁则优先用谁，没有则向上找（简介通过成员方法访问）

public void method(){ int num =30; System.out.println(num); System.out.println(this.num); System.out.println(super.num); } super是关键字

方法的覆盖 重写（名称与参数列表都一样）

创建的是子类方法，则优先使用子类方法 @Override 注解 判断是否正确覆盖 注：子类返回值必须小于等于父类方法的返回值范围 java.lang.Object类是最高父类 注：子类方法的权限必须大于等于父类方法的权限 public>protected>(default)>private default 不是关键字。而是什么都不写，留空

<1>继承关系中构造方法传播特点 先运行父类方法再运行（在子类构造方法中隐含一个super()“必须调用”） //有参父类对象 必须提供参数，否则报错 super的父类构造方法只能在子类中第一次调用->super构造只能在含参与非含参中选择一个

super关键字可以在子类方法定义中调用父类方法与父类变量

<2>this关键字 1.在本类的成员方法中访问成员变量 2.在本类的成员方法中访问另一个成员方法 3.在本类的构造方法中访问另一个构造方法 在第三种中要注意：A：this()调用也必须是构造方法的第一个语句，唯一一个 B：super与this 两种构造调用，不能同时使用 C：不能循环调用

<3> A.java只能单一继承 B:java可以多级继承 C:可以多个类同时继承一个父类

14.抽象 <1>.定义：public abstract class Animal{ public abstract void eat(); public void normalMethod(){ } }

<2>.使用 必须有一个子类继承抽象父类，必须覆盖重写抽象方法的abstract关键字 没有抽象方法的抽像类也不能直接使用 子类必须覆盖所有抽象方法（可以现在次级父类中先覆盖一部分）

=================================================================

15.接口 公共的规范标准 是一种引用数据类型 定义的格式

public interface 接口名称{ 接口内容 }

可包含内容：常量，抽象方法，默认方法，静态方法，私有方法（根据版本）

<1>抽象方法 格式：public abstract void methodAbs(); 1.修饰符必须是两个固定的关键字public abstract 2.两个关键词可以选择性忽略

实现 （1）接口必须有一个实现类来实现 格式：public class 实现类名称 implements 接口名称 （2）实现类必须覆盖所有抽象方法 去掉abstract关键字，加上方法体大括号 （3）创建实现类对象

如果实现类没有完全覆盖重写，那么实现类必须是抽象类

<2>默认方法（用于解决接口升级的问题，实现类不用改） 格式：public default 返回值类型 方法名称（参数列表）{方法体} 注：ctrl+c+v 可以复制方法名

实现：1.调用默认方法，如果实现类当中没有，会向上找接口 2.接口的默认方法，也可以被接口实现类覆盖重写

<3>静态方法 格式：public static 返回值类型 方法名称（参数列表）{方法体}

不能通过接口实现类的对象来调用接口当中的静态方法 通过接口名称，直接调用其中的静态方法

格式：接口名称.静态方法名； 静态方法与对象没有关系，只与类有关系

<4>私有方法 我们需要抽取一个共有方法，用于解决两个默认方法之间的重复代码问题 但这个共有方法不应让实现类来使用，应该是私有化的 1.普通私有方法，解决多个默认方法之间的重复代码问题 格式： private 返回值类型 方法名称（参数列表）{ 方法体 } 2.静态私有方法，解决多个静态方法之间的重复代码问题 格式： private static 返回值类型 方法名称（参数列表）{ 方法体 }

<5>接口的常量定义和使用 接口当中也可以定义“成员变量”，但是必须使用 public static final 三个关键字进行修饰 格式 publlic static final 数据类型 常量名称 =数据值； 一旦使用final 关键字修饰，不可改变 接口中的常量必须进行赋值 推荐常量名称使用完全大写的字母，用下划线进行分割

16.接口与继承 <1>.类与类之间是单继承的。直接父类只有一个。 <2>.类与接口之间是多实现的。一个类可以实现多个接口。 <3>.接口与接口之间是多继承的。

1.多个父接口当中的抽象方法如果重复，没有关系 2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字

注意事项 1.接口不能有静态代码块 接口不能有构造方法 2.一个类可以实现多个接口 3.如果直接父类的方法和，接口当中的默认方法产生了冲突，优先用父类当中的方法 public class Zi extends Fu implements MyInterface{}

17.多态性 extends继承或者implements实现，是多态性的前提 一个对象有多种形态，这就是多态性：父类引用指向子类对象

格式：父类名称 对象名=new 子类名称(); 或者; 接口名称 对象名 = new 实现类名称（）； 子类方法new的是谁就运行谁

多态中成员变量的使用特点 1.直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有则向上找

成员变量不能进行覆盖重写。

2.间接通过成员方法访问成员变量，看方法属于谁，优先用谁，没有则向上找

成员方法：编译看左边，运行看右边 成员变量：编译看左边，运行看左边

18.对象的上下转型 对象的向上转型：多态 向上转型一定是安全的（无法调用子类特有内容） 对象的向下转型：还原 格式 子类名称 对象名 = （子类名称）父类对象； 将父类对象还原为本来的子类对象 否则会报ClassCastException 错误

instanceof 关键字的使用 格式 对象 instanceof 类名称 会得到一个布尔值 与if语句共同使用

19.final（最终的不可变的）关键字 与内部类 <1>修饰类 当前类不能有任何子类 public final class MyClass { } final 类所有成员方法不能进行覆盖重写 <2>修饰方法 格式 修饰符 final 返回值类型 方法名称（参数列表）{方法体}

父类中final 方法不能覆盖重写 abstract 与final 不能同时使用

<3>作用于局部变量 final int num2=100; 一次赋值终生不变 final int num3; num3=100; 只能一次赋值

对于引用类型来说是指地址值不变；

<4> 修饰成员变量 1.成员变量具有默认值，所以必须手动赋值； 2.final 的成员变量 要么直接赋值，要么使用构造方法赋值； 3.必须保证类中所有重载的构造方法，都最终会对final变量进行赋值；

20.权限修饰符 public>protected>(default)>private

同一个类 Y Y Y Y 同一个包 Y Y Y N 不同包是子类Y Y N N （严格需要import） 不同包非子类 Y N N N

21.内部类 1.成员内部类 格式： 修饰符 class 外部类名称{ 修饰符 calss 内部类名称{ … } } 内用外，随意访问；外用内，需要内部类对象

使用： 1.在外部类的方法当中，使用内部类；然后main只是调用外部类方法 2.直接方式 公式： 外部类名称.内部类名称 对象名 =new 外部类名称（）.new 内部类名称（）；

<1>内部类同名变量访问 num 内部类局部变量 this.num 内部类成员变量 外部类名称.this.num 外部类成员变量

2.局部内部类 在一个方法内部使用 定义 修饰符 class 外部类名称{ 修饰符 返回值类型 外部类方法名（参数列表）{

calss 内部类名称{ ... } }

} 使用 外界无法访问

1.外部类 public / (default) 2.成员内部类 public / default /protected / privated 3.局部内部类 什么都不写

局部内部类与final

局部内部类 如果希望访问所在方法的局部变量，那这个变量必须是有效final的

3.匿名内部类 格式 接口名称 对象名 =new 接口名称（）{ 覆盖重写所有抽象方法 }；

注意 匿名对象【调用方法】+匿名内部类【创建对象】

类也可以作为一个成员变量 接口也可以作为一个成员变量 接口作为方法的参数和返回值 对应的学习视频