BASIC DAY01
1.Java开发环境:
1)java编译运行过程:------------常见面试题
1.1)编译期:.java源文件，经过编译，生成.class字节码文件
1.2)运行期:JVM加载.class并运行.class
特点:跨平台、一次编程到处使用
2)名词解释:--------------------常见面试题
2.1)JVM:java虚拟机
加载.class并运行.class
2.2)JRE:java运行环境
除了包含JVM以外还包含了运行java程序所必须的环境
JRE=JVM+java系统类库(小零件)
2.3)JDK:java开发工具包
除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK=JRE+编译、运行等命令工具
说明:
运行java程序的最小环境是JRE
开发java程序的最小环境是JDK
3)配置环境变量-------------------了解
3.1)JAVA_HOME:指向jdk的安装目录
3.2)CLASSPATH:表示类的搜索路径，一般简写为.(当前目录)
3.3)PATH:指向jdk下的bin目录(命令都在里面)
2.eclipse:
1)IBM、开源的、免费的、不需要安装仅需解压即可
2)开发步骤:
2.1)新建Java项目/工程---------------------小区
2.2)新建Java包----------------------------楼+单元
2.3)新建Java类----------------------------601
3)注释:解释性文本
3.1)单行注释://
3.2)多行注释:/* */
3.3)文档注释:/** */-------------4月底讲
BASIC DAY02
1.变量:存数的，代词，指代的是它所存的那个数
1)声明:
int a; //声明一个整型的变量，名为a
int b,c,d; //声明三个整型的变量，名为b,c,d
2)初始化:第一次赋值
2.1)声明的同时初始化:
int a = 250; //声明整型变量a并赋值为250
2.2)先声明后初始化:
int a; //声明整型变量a
a = 250; //给变量a赋值为250
3)使用:
3.1)对变量的使用就是对它所存的那个数的使用
int a = 5;
int b = a+10; //取出a的值5，加10后，再赋值给整型变量b
System.out.println(b); //输出变量b的值15
System.out.println("b"); //输出b，双引号中的原样输出
a = a+10; //取出a的值5，加10后，再赋值给a
//在a本身基础之上增10
System.out.println(a); //输出变量a的值15
3.2)变量的使用必须与数据类型匹配
int a = 3.14; //编译错误，数据类型不匹配
3.3)变量在前之前必须声明并初始化
System.out.println(m); //编译错误，变量未声明
int m;
System.out.println(m); //编译错误，变量未初始化
4)命名:
4.1)只能包含字母、数字、_和$符，并且不能以数字开头
4.2)严格区分大小写
4.3)不能使用关键字(具有特殊含义的字)
4.4)可以中文命名，但不建议
建议:"英文的见名知意"、"驼峰命名法"
2.基本数据类型:
1)int:整型，4个字节，-21个多亿到21个多亿
1.1)整数直接量默认为int类型，但不能超出范围，若超范围则编译错误
1.2)两个整数相除，结果还是整数，小数位无条件舍弃
1.3)整数运算时超出范围，则发生溢出，溢出是需在避免的
2)long:长整型，8个字节，很大很大很大
2.1)长整型直接量需在数字后加L或l
2.2)运算时若有可能溢出，建议在第1个数字后加L
2.3)System.currentTimeMillis()用于获取自
1970.1.1零时到此时此刻的毫秒数
3)double:浮点型，8个字节，很大很大很大
3.1)浮点型直接量默认为double型，表示float需在数字后加f或F
3.2)double和float型数据运算时，有可能会出现舍入误差，所以精确运算场合不能用
4)boolean:布尔型，1个字节
4.1)只能取值为true或false
5)char:字符型，2个字节
5.1)采用Unicode字符集编码，每个字符对应一个码
表现的形式是字符char，实质上存储的是码int(0到65535)
(ASCII码: 'a'--97 'A'--65 '0'--48)
5.2)字符直接量必须放在单引号中，只能有一个
5.3)特殊符号需要通过\来转义
3.基本数据类型间的转换:
基本类型从小到大依次为:
byte,short,int,long,float,double
char,
1)两种方式:
1.1)自动类型转换:从小类型到大类型
1.2)强制类型转换:从大类型到小类型
语法:(要转换成为的数据类型)变量
强转有可能会溢出或丢失精度
2)两点规则:
2.1)整数直接量可以直接赋值给byte,short,char，但不能超出范围
2.2)byte,short,char型数据参与运算时，先一律转换为int再运算
4.Scanner的用法:
1)在package下:
import java.util.Scanner;
2)在main方法中:
Scanner scan = new Scanner(System.in);
3)在第2步之下:
System.out.println("请输入年龄:");
int age = scan.nextInt();
System.out.println("请输入价格:");
double price = scan.nextDouble();
BASIC DAY03
1.运算符:
1)算术:+,-,*,/,%,++,--
2)关系:>,<,>=,<=,==,!= boolean
3)逻辑:&&,||,! boolean
4)赋值:=,+=,-=,*=,/=,%=
5)字符串连接:+
6)条件/三目:boolean?数1:数2
2.分支结构:
1)if结构:1条路
2)if...else结构:2条路
3)明天讲
4)明天讲
BASIC DAY04
1.分支结构:
1)if结构:1条路
2)if...else结构:2条路
3)if...else if结构:多条路
4)switch..case结构:多条路
优点:效率高、结构清晰
缺点:整数、相等
break:跳出switch
2.循环:
1)反复执行一段相同或相似的代码
2)循环三要素:
2.1)循环变量的初始化
2.2)循环的条件(以循环变量为基础)
2.3)循环变量的改变(向着循环结束变)
循环变量:在整个循环过程中所反复改变的那个数
3)循环结构:
3.1)while:先判断后执行，有可能一次都不执行
3.2)do...while:先执行后判断，至少执行一次
要素1与要素3相同时，首选do...while
BASIC DAY05
1.for:固定次数循环，应用率高
2.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环
3.三种循环结构的更佳适用情况:
1)while:要素1与要素3不同时，首选while
2)do...while:要素1与要素3相同时，首选do...while
3)for:固定次数循环，应用率最高
4.嵌套循环:
1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
2)执行规则:外层循环走一次，内层循环走所有次
3)建议:循环层数越少越好，能用一层就不用两层，能用两层就不用三层，
若需求必须通过三层以上的循环来解决，说明设计有问题
4)break只能跳出一层循环
5.程序=算法+数据结构
1)算法:解决问题的流程/步骤(顺序、分支、循环)
2)数据结构:将数据按照某种特定的结构来保存(数怎么存)
设计合理的/良好的数据结构会导致好的算法
6.数组:
1)是一种数据类型(引用类型)
2)相同数据类型元素的集合
3)数组的定义:
int[] arr = new int[10];
4)数组的初始化:
int[] arr = new int[4]; //0,0,0,0
int[] arr = {1,4,5,7}; //1,4,5,7
int[] arr = new int[]{1,4,5,7}; //1,4,5,7
int[] arr;
arr = {1,4,5,7}; //编译错误，此方式只能声明的同时初始化
arr = new int[]{1,4,5,7}; //正确
5)数组的访问:
5.1)通过(数组名.length)来获取数组的长度(元素的个数)
int[] arr = new int[4];
System.out.println(arr.length); //4
5.2)通过下标/索引来访问数组中的元素
下标从0开始，最大到(数组的长度-1)
int[] arr = new int[3];
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200; //给arr中第2个元素赋值为200
arr[2] = 300; //给arr中第3个元素赋值为300
arr[3] = 400; //数组下标越界异常
System.out.println(arr[arr.length-1]); //输出arr中最后一个元素的值
6)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i] = 100;
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
BASIC DAY06
1.数组:
1)复制:
1.1)System.arraycopy(a,1,a1,0,4);
1.2)int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
2)排序:
2.1)Arrays.sort(arr); //升序
2.2)冒泡排序:
2.2.1)五个数冒四轮
2.2.2)每一轮都是从第1个元素开始冒
每一次都是和它的下一个元素比
2.2.3)冒出来的就不带它玩了
2.方法:
1)封装一段特定的业务逻辑功能
2)方法尽可能独立，只干一件事
3)方法可以被反复多次的调用
4)减少代码的重复，有利于代码的维护，有利于团队的协作
3.方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
4.方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
5.return:
1)return 值; //1.1)结束方法的执行 1.2)返回结果给调用方
-------------------用在有返回值的方法中
2)return; //2.1)结束方法的执行
-------------------用在无返回值的方法中
BASIC DAY07
猜字符小游戏:
1.设计数据结构:变量
1)char[] chs; //随机字符数组
2)char[] input; //用户输入的字符数组
3)int[] result; //对比的结果
4)int score; //得分
2.设计程序结构:方法
1)主方法:
public static void main(String[] args){
//...
}
2)生成随机字符数组chs:
public static char[] generate(){
char[] chs = new char[5];
//...
return chs;
}
3)对比:随机字符数组chs与用户输入的字符数组input
public static int[] check(char[] chs,char[] input){
int[] result = new int[2];
//...
return result;
}
3.设计算法:方法体
String str = "abc";
1)将字符串转换为字符数组
char[] input = str.toCharArray();
2)将字符串转换为大写字母
str = str.toUpperCase();
将字符串转换为大写字母
str = str.toLowerCase();
3)判断字符串内容是否相等
if(str.equals("ABC")){
}
OO DAY01
1.什么是类？什么是对象？
1)现实世界是由很多对象组成的
基于对象抽出类
2)对象:真实存在的单个的个体
类:类型/类别，代表一类个体
3)类中可以包含:
3.1)所有对象所共有的属性/特征----------------成员变量
3.2)所有对象所共有的行为---------------------方法
4)一个类可以创建多个对象，
同一类型的多个对象，结构相同，数据不同
5)类是对象的模板，对象是类的具体的实例
2.如何创建类？如何创建对象？如何访问成员？
OO DAY02
1.方法的重载(Overload):
1)发生在一个类中，方法名称相同，参数列表不同
2)编译器在编译时会根据方法的签名自动绑定调用的方法
2.构造方法:构造函数、构造器，构建器
1)给成员变量赋初值
2)与类同名、没有返回值类型
3)在创建(new)对象时被自动调用
4)若自己不写构造方法，则编译器默认一个无参构造方法，
若自己写了构造方法，则不再默认提供
5)构造方法可以重载
3.this:指代当前对象，哪个对象调用方法指的就是哪个对象
只能用在方法体中，方法中访问成员变量之前默认有个this.
this的用法:
1)this.成员变量名--------------访问成员变量
2)this.方法名()----------------调用方法(几乎不用)
3)this()-----------------------调用构造方法
OO DAY03
1.引用类型数组:
1)Student[] stus = new Student[3];
stus[0] = new Student();
stus[1] = new Student();
stus[2] = new Student();
stus[1].age = 25; //给第2个学生的年龄赋值给25
2)Student[] stus = new Student[]{
new Student(),
new Student(),
new Student()
};
3)int[][] arr = new int[3][];------------数组的数组
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
arr[1][0] = 100; //给arr第2个元素中的第1个元素赋值为100
4)int[][] arr = new int[3][4];
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
arr[i][j] = 100;
}
}
2.继承:
1)作用:代码复用
2)通过extends来实现继承
3)超类:所有派生类所共有的属性和行为
派生类:派生类所特有的属性和行为
4)派生类继承超类后，派生类具有:派生类的+超类的
5)一个超类可以有多个派生类
一个派生类只能有一个超类-----------单一继承
6)继承具有传递性
7)java规定:构造派生类之前必须构造超类
在派生类的构造方法中，若自己不调用超类的构造方法
--------------则默认super()调用超类的无参构造方法
在派生类的构造方法中，若自己调用了超类的构造方法
--------------则不再默认提供
super()调用超类的构造必须位于派生类构造中的第一行
3.super:指代当前对象的超类对象
super的用法:
super.成员变量名---------访问超类的成员变量
super.方法名()-----------调用超类的方法---------下次课讲
super()------------------调用超类的构造方法
4.null:空，没有指向任何对象
若引用的值为null，则该引用不能进行任何操作
若操作则发生NullPointerException空指针异常
OO DAY04
1.向上造型:
1)超类型的引用指向派生类的对象
2)能点出来什么，看引用的类型
2.方法的重写(Override):重新写、覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
3)遵循"两同两小一大"原则:-----------了解
3.1)两同:
3.1.1)方法名称相同
3.1.2)参数列表相同
3.2)两小:
3.2.1)派生类方法的返回值类型小于或等于超类方法的
1)void时，必须相等
2)基本类型时，必须相等
3)引用类型时，小于或等于
3.2.2)派生类方法抛出的异常小于或等于超类方法的-----异常之后
3.3)一大:
3.3.1)派生类方法的访问权限大于或等于超类方法的-----明天讲
3.重写与重载的区别:---------常见面试题
1)重写(Override):
1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
1.2)遵循"运行期"绑定，看对象的类型来调用方法
2)重载(Overload):
2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同
2.2)遵循"编译期"绑定，看参数/引用的类型来绑定方法
OO DAY05
1.package:
1)作用:避免类的命名冲突
2)类的全称: 包名.类名
3)包名可以有层次结构
4)建议:包名所有字母都小写
import:
1)同包中的类可以直接访问，
不同包中的类不能直接访问，想访问有如下两种方式:
1.1)先import声明类，再直接访问类-----建议
1.2)类的全称-------------------------太繁琐，不建议
2.访问控制修饰符:
1)public:公开的，任何类
2)protected:受保护的，本类、子类、同包类
3)默认的:什么也不写，本类、同包类
4)private:私有的，本类
说明:
1)类的访问修饰符只能是public或默认的
2)类中成员的访问修饰符如上4种都可以
3.final:最终的、不可改变的-------应用率低
1)修饰变量:变量不能被改变
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
4.static:静态的
1)静态变量:
1.1)由static修饰
1.2)属于类的，存储在方法区中，只有一份
1.3)常常通过类名点来访问
1.4)何时用:所有对象所共享的数据(图片、音频、视频等)
2)静态方法:
2.1)由static修饰
2.2)属于类的，存储在方法区中，只有一份
2.3)常常通过类名点来访问
2.4)静态方法没有隐式的this传递，
所以在静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
3.1)属于类的，在类被加载期间自动执行的，
因类只被加载一次，所以静态块也只执行一次
3.2)何时用:初始化/加载静态资源(图片、音频、视频等)
5.static final常量: 明天讲
OO DAY06
1.static final常量: 应用率高
1)必须声明同时初始化
2)通过类名点来访问，常量不能被改变
3)建议:常量名所有字母都大写，多个单词用_分隔
4)编译器在编译时将常量自动替换为具体的值，效率高
5)何时用:数据经常使用，并且永远不变
2.抽象方法:
1)由abstract修饰
2)只有方法的定义，没有方法的具体实现(连{}都没有)
3.抽象类:
1)由abstract修饰
2)包含抽象方法的类必须是抽象类
不包含抽象方法的类也可以声明为抽象类-------我乐意
3)不能被实例化
4)抽象类是需要被继承的，派生类:
4.1)重写抽象类中的所有抽象方法-----变不完整为完整
4.2)也声明为抽象类-----------------不常用
5)抽象类的意义:
5.1)封装派生类所共有的属性和行为--------代码复用
5.2)为所有派生类提供一种统一的类型------向上造型
5.3)可以包含抽象方法，为所有派生类提供统一的入口，
派生类的具体行为不同，但入口是一致的
设计规则:
1)将所有派生类所共有的属性和行为，抽到超类中-------抽共性
2)所有派生类的行为都一样，设计为普通方法
所有派生类的行为都不一样，设计为抽象方法
3)
OO DAY07
1.成员内部类: 应用率低
1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类
2)内部类通常只服务于外部类，对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象
外部类名.this
2.匿名内部类:
1)若想创建一个类的对象，并且对象只被创建一次，
此时该类不必命名，称之为匿名内部类
2)匿名内部类中访问外面的变量，该变量在jdk1.8以前必须是final的
常见面试题:
问:内部类有独立的.class吗?
答:有
OO DAY09
1.接口:
1)是引用数据类型
2)由interface定义
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的，实现类/派生类:
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，用逗号分隔
若又继承又实现时，应先继承后实现
7)接口可以继承接口
2.多态:
1)意义:
1.1)同一类型的引用在指向不同的对象时，有不同的实现
------行为的多态:cut(),run(),step()...
1.2)同一个对象被造型为不同的类型时，有不同的功能
------对象的多态:我，水...
2)向上造型:
2.1)超类型的引用指向派生类的对象
2.2)能造型成为的类型有: 超类+所实现的接口
2.3)能点出来什么，看引用的类型
3)强制类型转换，成功的条件只有如下两种:
3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，实现了该接口/继承了该类
4)强转若不符合如上两个条件，则发生ClassCastException类型转换异常，
建议:强转之前instanceof判断引用指向的对象是否是该类型
设计规则:
1)将所有派生类所共有的属性和行为，设计在超类中
2)所有派生类行为都一样，设计为普通方法
所有派生类行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，设计在接口中
符合既是也是原则时，使用接口
接口是对继承的单根性的扩展----------实现多继承
OO DAY11
1.内存管理:由JVM管理---------------了解
1)堆:
1.1)用于存储new出来的对象(包括实例变量)
1.2)垃圾:没有任何引用所指向的对象
垃圾回收器(GC)不定时到内存中清扫垃圾，
回收的过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，
调用System.gc()可以建议虚拟机尽快调度GC来回收
1.3)内存泄漏:不再使用的内存还没有被及时的回收
严重的泄漏会导致系统的崩溃
建议:对象不再使用时及时将引用设置为null
1.4)实例变量的生命周期:
创建对象时存在堆中，对象被回收时一并被回收
2)栈:
2.1)存储正在调用的方法中的所有局部变量(包括参数)
2.2)调用方法时在栈中为该方法分配一块对应的栈帧，
栈帧中存储方法的局部变量(包括参数)，
方法执行结束后，栈帧被清除，局部变量一并被清除
2.3)局部变量的生命周期:
调用方法时存储在栈中，方法结束栈帧被清除时一并被清除
3)方法区:
3.1)用于存储.class字节码文件(包括方法、静态变量)
3.2)方法只有一份，需要通过this来指代具体的对象
面向对象三大特征:--------------------面试题
1.封装:
1)类:封装的是对象的属性和行为
2)方法:封装一段特定的业务逻辑功能
3)访问控制修饰符:封装的是具体的访问权限
2.继承:
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
接口:部分派生类所共有的行为
派生类:派生类所特有的属性和行为
3)传递性、单一继承，多接口实现
3.多态:
1)行为多态(所有抽象方法)、对象多态(所有对象)
2)向上造型、强制类型转换(想访问派生类所特有的)、instanceof判断
3)多态的表现形式:
3.1)重写:根据对象的不同来多态
3.2)重载:根据参数的不同来多态
