1，配置JDK环境变量
1，新建JAVA_HOME变量
JAVA_HOME
E:\install\java\jdk-11.0.2----------JDK安装路径
2，编辑Path变量
%JAVA_HOME%\bin
3，测试
打开DOS 窗口输入：java -version
2,DOS命令
cmd 进入DOS系统
x: 切换盘符
dir 显示当前目录下所有文件和文件夹
md 新建指定名字的文件夹
cd 进入目录，返回上一级，返回根目录
rd 删除指定名字的目录
ipconfig 查看当前计算机的IP地址配置
ping 测试网络是否连接通
cls 清屏
3,Java标识符
参考阿里巴巴开发手册：《阿里巴巴Java开发手册（终极版）》-藏经阁-阿里云开发者社区 (aliyun.com)
标识符只能包含数字,字母,_,$,不能使用数字开头
如果是文件名：每个单词首字母都大写
如果是数据名：除第一个单词外，其余单词首字母大写:myName,userName,xingBie,diZhi
4，计算机中的数据保存
计算中数据都是按照二进制保存，保存是补码：
正数：直接将正数转化为二进制:源码=反码=补码
负数：反码将负数的源码按位取反(1变0,0变1) 补码是反码+1
二进制相加运算规则满二进位1，运算过程中最高1自动丢弃。
5，java常规操作
1，异或取反
x=x^y y=x^y x=x^y
2,键盘输入
Scanner input = new Scanner(System.in)
String s = input.next()
3，Switch结构
多重if可以进行区间判断，也可以进行等值判断，Switch只能进行等值判断
switch（表达式）{
case 常量：执行语句；
break；
default：默认执行语句；
4，java循环结构
1，while循环
while（循环条件）{
循环体}
2，for循环
for（循环变量初始值；循环条件；更新循环变量）{
循环体}
3，do-while循环
至少循环1次
do{
循环体；
}while循环条件）；
4， break和continue关键字
break；中断循环，直接退出
continue；中断本次循环，进入下一次循环
5，死循环
while（true）
for（；；）
5，双重循环练习
1，99乘法表
2，三角形
6，java方法
语法：
返回值类型 方法名(形参列表....,....){
方法体
}
递归计算n的阶乘
1，方法重载
同一个java文件内方法名字相同，参数列表不同，如下图的系统方法重载：
方法的形参是基本类型，传入的实参是数据的副本
方法的形参是引用类型，传入的实参是引用地址的副本
7，数组
1，语法：
数据类型[] 数组名=new 数据类型[n];
数据类型[] 数组名={元素1,元素2,...,....元素n}
2，循环数组
for(int x=0;x<array.length;x++)
3，基本方法
插入元素：insert (数组变量名，下标，值)
删除元素：delete (数组变量名，下标)
扩容数组：int[] newArr=new int [Arr.length*2]
4，数组的二分查找方法：
5，数组冒泡排序方法
6, 二维数组
语法：
数据类型[][] 数组名=new 数据类型[m][n];
数据类型[][] 数组名={{},{},{}};
8，面向对象
1，this关键字
This关键字存在于每个非static修饰的方法。
This表示的是某个对象的引用地址,哪个对象调用该方法，this就引用哪个对象的地址。
2， package命名规范
Package命名全部字母小写，如果多个单词使用点号隔开,比如abc.xyz形成多级目录
实际中一般使用公司域名倒置,jd.com--->com最为前缀。
3，java继承
关键字：extends 用来建立子类和父类的继承关系，子类 extends 父类。
Java继承只能是单根继承,一个类只能存在一个直接父类。
1，super关键字
用来标识父类。
可以在子类调用父类的构造方法。
可以在子类的实例方法中调用父类的实例方法。
实例方法：使用对象调用的方法，非静态方法
2，方法重写
子类定义方法重写覆盖父类的方法
重载和重写的区别：
- 重载发生在本类，重写发生在父类与子类之间
- 重载的方法名必须相同，重写的方法名相同且返回值类型必须相同
- 重载的参数列表不同，重写的参数列表必须相同
- 重写的访问权限不能比父类中被重写的方法的访问权限更低
- 构造方法不能被重写
3， Abstract关键字
Abstract 修饰类，抽象类
语法：public abstract class 类名{}
一个类中包含抽象方法，那该类必须使用abstract修饰---抽象类
抽象类中不一定所有方法都是抽象方法
抽象类不能实例化。只能创建子类重写抽象方法，然后创建子类对象使用
子类必须重写父类中的抽象方法
抽象类一定会被继承
4，java多态
同一个行为(方法)，存在多种不同的表现形式或者形态。
方式一:父类类型的变量，引用子类类型的对象
Fu x=new Zi();
方式二:声明方法形参是父类类型变量
method(Fu x){}
调用方法实参是子类类型的对象
Zi y=new Zi();
Method(y);
事例：
1，创建父类Printer类
public abstract class Printer {
/*定义打印机的打印方法*/
public abstract void daYin(String content);
}
2，创建子类ColorPrinter类
public class ColorPrinter extends Printer{
@Override
public void daYin(String content) {
System.out.println("实现彩色打印:"+content);
}
}3，创建子类WhiltePrinter类
public class WhiltePrinter extends Printer{
@Override
public void daYin(String content) {
System.out.println("实现黑白打印:"+content);
}
}4，创建PrinterTest类
public class PrinterTest {
public static void main(String[] args) {
//声明父类类型的变量x
Printer x=null;
//x引用ColorPrinter的对象,父类类型变量引用子类类型对象
x=new ColorPrinter();
//调用打印机打印方法
//编译左边(父类)，运行右边(子类)
//多态前提条件:存在继承(父类引用子类)和方法的重写(不同子类表现不同的形态)
x.daYin("嘻嘻嘻嘻嘻嘻");
//x引用WhiltePrinter对象
x=new WhiltePrinter();
//编译左边(父类)，运行右边(子类)
x.daYin("的点点滴滴多多多");
}
}5，创建Employee类
public class Employee {
/*员工类工作的方法，实现数据打印
* 形参父类:Printer可以接收任意自己的子类对象
* */
public void work(Printer printer,String data){
//编译左边，运行右边(传入不同的子类对象)，daYin方法绑定到不同子类对象上。
printer.daYin(data);
}
}6，创建EmployeeTest类
public class EmployeeTest {
public static void main(String[] args) {
//创建Employee类对象
Employee employee=new Employee();
//创建ColorPrinter对象
ColorPrinter colorPrinter=new ColorPrinter();
//调用员工工作的方法，传入实参是子类类型的对象
employee.work(colorPrinter,"多大点事");
//创建WhiltePrinter对象
WhiltePrinter whiltePrinter=new WhiltePrinter();
employee.work(whiltePrinter,"XXXX");
}
}5，Final关键字介绍
修饰变量: final 数据类型 变量名=value; final修饰变量变为常量。
修饰方法: final 返回值类型 方法名(形参列表....){},该方法不能被重写。
修饰类: final class 类名{}, 该类不能被继承。
常量命名规范：所有字母大写，多个单词使用下划线隔开
6，接口
定义的是抽象方法的集合，抽象类的特殊形式。
深层次理解:理解为实际开发过程中团队协作定义的规范。
Java的类是单根继承，Java的接口实现可以多继承的。
Java类可以继承某个类的同时，实现多个Java接口，单继承多实现。
Java接口类型的变量可以引用实现类的对象---接口多态。
9，String
1，String用法
//获得String对象
String s1="xyz";
String s2=new String("abc");
//声明char类型数组
char[] chars={'乌','龟'};
//将chars数组转化为字符串
String s3=new String(chars);//s3=乌龟
//声明byte类的数组
byte[] bytes={97,98,99,100};
//将bytes转化为字符串
String s4=new String(bytes,0,2);//s4=ab
//charAt(),通过指定下标，获得下标处的字符
char c = s1.charAt(1);//c=y
//进行字符串的追加拼接
String s5 = s1.concat(s2);//s5=xyzabc
//判断s5字符串是否包含s1字符串
boolean contains = s5.contains(s1);//contains=true
//声明字符串变量
String s6="xyz";
String s7=new String("xyz");
System.out.println(s1==s6); //true
System.out.println(s1==s7); //false ,双等号比较的地址
System.out.println(s1.equals(s6)); //true
System.out.println(s1.equals(s7)); //true,String重写equals方法
//将字符串转化为大写
String s8 = s1.toUpperCase();//s8=XYZ
String s9 = s8.toLowerCase();//s9=xyz
//忽略大小写比较
boolean ignoreCase = s8.equalsIgnoreCase(s9);//ignoreCase=true
//获得字符串s8某个字符串出现的位置(第一次)，如果不存在返回-1
int indexOf = s8.indexOf("YZ");//1
//获得字符串s8某个字符串出现的位置(最后一次)
int lastIndexOf = s8.lastIndexOf("YZ");//1
//获得字符串中每个字符的编码
byte[] s9Bytes = s9.getBytes();
System.out.println(s9Bytes+"---"+ Arrays.toString(s9Bytes));
//將字符串使用指定符号进行拼接
String join = String.join("-", "a", "b", "c", "d");//a-b-c-d
//获得字符串长度
int length = join.length();//length=7
//将字符串使用指定的符号进行分割，返回分割后形成字符串数组
String[] split = join.split("-");//a, -, b, -, c, -, d
//将字符串转化为字符串数组
char[] charArray = join.toCharArray();//
System.out.println(charArray+"==="+Arrays.toString(charArray));
//截取子字符串,截取指定下标区间内的字符串([1,4))
String substring = join.substring(1, 4);//-b-
//进行字符串中字符的替换
String replace = join.replace("-", "*");//a*b*c*d
//判断字符串是不是以某个字符串打头
boolean starts = "李白".startsWith("李");//true
//判断字符串是不是以某个字符串结尾
boolean ends = "Hello.java".endsWith(".java");//true2，StringBuffer用法
StringBuffer 是线程同步的，安全的。能保证数据安全，效率低。
append();
delete();
insert();
reverse();
indexOf();
lastIndexOf();
charAt();
substring();
3，StringBuilder用法
StringBuilder 是线程不同步的，不安全的。没法保证数据安全，效率高。
4,异常处理
throw关键字抛出的运行时异常，可以不处理
thows关键字抛出的检查时异常，必须处理
扫一扫
388
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
