day01
java基础
1.关键字:是被java赋予了特殊含义的单词,咱们只能用不能改,也不能跟这些关键字重名
2标识符:程序中需要我们自己命令的
//不能跟关键字重名
//标识符中只能包含字母,数字,_和$
//区分大小写 A a
//不能以数字开头
//注意:可以使用中文作为标识符,但是一般不使用.
3.常量:固定不变的量
变量:存储程序中用到的数据,它存储的数是可以改变的,只能存储一个数
4.数据类型
分类:第一种分法是根据数据类型分.
第一:基本数据类型
数值型 范围
>byte型 1个字节 [-27,27-1]
>short型 2个字节 [-215,215-1]
>int 4个 [-231,231-1]
>long 8个 [-263,263-1]
布尔型
>boolean 1个
浮点型(小数)
>float 4个
>double 8个
字符型
>char 1个
5.类型转换
类型的高低是根据数据类型表示的数范围的大小确定的.
自动类型转换 :数据类型从低类型转成高类型,没有数据的损失
强制类型转换:数据类型从高类型转成低类型,有可能会出现数据的损失.
6.char相关的内容
char 1个字节,默认对应的语言是英文,字符集是ASCII 0-48 A-65 a-97
针对中文: 对应的字符集是GBK/GB2312 一个汉字2个字节
常用的字符集: GBK(中国标准) UTF-8(国际通用标准) ASCII(国标) uncode(内部编码) ISO8859-(欧洲标准)
对于中文: 2个字节 3个字节 不支持中文 2个字节 不支持中文
我们通常把字符串转成二进制的过程称为编码
将二进制转成字符串的过程称为解码
-
运算符: 分类: 第一:根据类型分类 算数运算符:+ - * / % ++(自增) --(自减)
赋值运算符:= += -= *= /= %= ^=
逻辑运算符:&& || !
关系运算符:== < <= > >= !=
位运算符:操作位的. & | ^ ~
移位运算符:操作位的. >> << >>>
第二:根据操作元素个数分类
算数运算符:+ - * / % ++(自增) --(自减)
短路与:当一个式子中有多个连续的&&,我们只需要找出第一个false,即可停止运算.因为只要有一个false,整体结果就是false
短路或:当一个式子中有多个连续的||,我们只需要找出第一个true,即可停止运算.因为只要有一个true,整体结果就是true
8.移位运算符 >> 有符号右移 << 有符号左移 >>> 无符号右移
>>1 右移一位:代表除以2
<<1 左移一位:代表乘以2
9.dowhile 与while的区别:就是dowhile不管条件成立与否,语句都会先执行一次
10.循环可以嵌套,可以给for循环添加标识,我们可以认为是给他起了一个别名.
11.函数的构成:
修饰词 返回值类型 函数名(参数列表){
函数的功能代码;
return 返回值;
}
修饰词:限定当前函数的可见范围的,暂时先忽略
*返回值类型:可以有,也可以没有,如果没有需要些void
函数名:必须有,命名规则:遵循小驼峰原则(当有多个单词组成名字的时候,除第一个单词外,所有单词的首字母大写)
函数名:要做到见名知意
参数列表:1.可以有,可以没有 2.如果有,可以有一个或多个,多个参数之间以,隔开
return 返回值; 这里是一个动作,后面放的是要返回的数据,要求:返回值类型要与return后面的类型一致
注意点:return后面只能放一个数据
特点:有结束的意思
注意:函数之间可以调用,但是不能嵌套
//函数的调用:通过函数的名字发生的调用
12函数
if,for等可以嵌套.但是函数的定义不能嵌套,调用可以.
- 函数的功能必须通过调用实现
- 函数有功能单一性原则.即一个函数中最好只有一个功能.
- 函数的作用:可以提高程序的安全性,复用性,健壮性,可读性,节省内存.
13.函数功能
1)直接定义在函数,for,if等中的变量称为局部变量.
局部变量只在他所在的函数,for,if中可见可用.出了这个范围就会从内存中消失.
2)我们把函数定义处的变量称为形参:形式上的参数
把函数调用处的变量称为实参:实际的参数
形参必须通过接受实参的值才能起作用.
我们在定义形参和实参时注意:
参数的个数要一致
参数的位置要一致
参数的类型要一致
3)return注意点:
返回数据,将数据往外抛
结束的意思,在表示结束时,函数不一定有返回值.
14.java将内存分成了5块儿,分别是堆区,栈区,方法区,本地方法区,寄存器
栈区:里面存放数据的特点是:先进后出,我们主要将局部变量和函数放在栈区,数据的特点是使用完立刻释放
堆区:存放的是实体(对象和数组),实体可以同时存放多个值,实体里面的变量如果不赋值,会有默认值.整型数据默认值是0,boolean—false
15.函数的重载:在同一个类中,方法名相同,参数不相同的方法的关系
- 注意点:
- 1.参数的个数不同是重载
- 2.参数的类型不同是重载
- 3.参数的位置不同是重载
- 4.重载与返回值无关
- 5.重载与参数的名字无关
- 6.重载的方法本质上还是不同的方法.
day02
数组
1.数组可以存储多个相同数据，本身是引用数据类型 放在堆区 有默认值。
2.引用数据类型里面存储地址（16进制数），简单数据类型存值（10进制数）。
3.new 动态开辟内存空间（需要的时候），然后当前地址返回给变量（变量存地址），所以存地址的叫引用数据类型。
4.数组第一个元素的地址就是（充当）整个数组的地址，数组内存连续，计算机单位默认是字节。1234 1238 123C 然后就能用下标了。
5.引用的本质 变量只告诉地址 ，具体操作是对象本身（数组）。
6.int[] arr = {1,2,3,4} 数组作为参数时。不能直接写大括号这种创建数组方式。
7.main方法入栈 方法里有变量。
8.ArrayIndexOutOfBoundsException。
9.值传递：传基本数据类型。址传递：传递地址。根本是两个引用指向同一地址进行操作。
二维数组
1.二维数组：第二个是一个建议值， 一维数组位置放的二维数组地址，创建时数组里放数组并且分开写是可以的。
int[][] arr=new int[1][1];
arr[0]=new int[]{1,2,4,5};//全存储了
排序
重点掌握:冒泡,选择,希尔**,快速排序,归并排序**,插入排序。
各算法的时间复杂度
平均时间复杂度
插入排序 O(n2)
冒泡排序 O(n2)
选择排序 O(n2)
快速排序 O(n log n)
堆排序 O(n log n)
归并排序 O(n log n)
基数排序 O(n)
希尔排序 O(n1.25)
//冒泡排序:先确定最大值
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++) {//确定一个元素需要比较的次数
if (arr[j] > arr[j+1]) {//交换---改结束值
arr[j] = arr[j] ^ arr[j+1];
arr[j+1] = arr[j] ^ arr[j+1];
arr[j] = arr[j] ^ arr[j+1];
}
}
}
}
//选择排序:先确定最小值
public static void SelectedSort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {//确定的是整体的次数,比元素的个数少一
for (int j = i; j < arr.length-1; j++) {//确定一个元素需要比较的次数
if (arr[i] > arr[j+1]) {//交换---改起始值
arr[i] = arr[i] ^ arr[j+1];
arr[j+1] = arr[i] ^ arr[j+1];
arr[i] = arr[i] ^ arr[j+1];
}
}
}
}
查找
1.二分查找是重点 数组必须有序
m=(l+r)/2; 或 m=(l+r)>>1;
r=m-1; l=m+1;
结束条件：l>r while循环
//二分查找
public static int binarySearch(int[] arr,int key) {
int l = 0;
int r = arr.length-1;
int m ;
while (l<=r) {
m = (l+r)>>1;//这里使用移位运算符做除法
if (key == arr[m]) {
return m;//查到后返回下标
}else if (key > arr[m]) {
l = m+1;
}else if (key < arr[m]) {
r = m-1;
}
}
return -1;
}
面向对象
1.面向过程：
-
强调的是功能行为 。
-
关注的是解决问题需要哪些步骤。
2.面向对象：
-
将功能封装进对象 强调具有功能的对象 。
-
关注的是解决问题需要哪些对象。
3.面向对象是基于面向过程的 ，HTML是面向对象的。
4.怎么理解面向对象？
-
二者都是都是编程思想。
-
面向对象是基于面向过程的。
-
面向对象是比面向过程更高级的编程思想。
-
面向对象是更符合人们思考习惯的思想。
-
让编程人员从执行者变成指挥者。
-
将复杂事情简单化。
5.类是对象的抽象。
6.类：描述事物就是描述事物的名称、属性、行为。拥有相同（相似）属性和行为的对象都可以抽象出一个类。
7.构造方法对对象进行初始化（赋值）。
8.单引号只能写一个字符。数组就是特殊的对象。
9.没有引用指向的对象（匿名对象）会被垃圾回收机制回收。
匿名对象：节省代码 节省内存。作为参数传递。test（new Dag（））；方法里接受的是new返回的地址。匿名内部类。
10.人有孩子，人有人的属性 。
11.一个类型一旦创建出来,就是一个独立的数据类型,在他可见的范围内都是可以使用的,包括自己的内部
static 关键字
1.static 修饰成员变量，就是静态成员变量。应该由类调用，如果对象调用会有警告。非静态只能由对象调用。
2.静态方法放到方法区还会放到静态方法区一份，放入后方法生命周期跟类一致（.class文件一致）。
3.静态成员变量放在静态方法区的静态方法里而不是在堆的对象里。
4.类调用静态成员变量是字节码文件在干活。字节码文件本身是对象。
5.优先使用静态成员方法。非静态至少两次 ，静态字节码直接一次查找。效率高。没有对象也可以调用。但是生命周期长占用极少 框架。
注意：静态方法中要使用非静态属性必须使用非静态成员变量。否则静态方法使用的时候非成员变量还不一定在。
6.静态工具类：类里方法都是静态 一些工具方法（查找啊、排序呀）。重点啊，自己多封装。
构造方法
1.构造方法形参随便起名。但是创建时就不知道每个参数就不知道如何赋值。所以形参要和实参一致。this.name = name;否则就近原则变成，局部变量=局部变量。默认引用数据类型，保存当前对象引用可以点类中的成员变量和方法。 点出来的一定是成员变量。this可以充当构造方法。 dameo13 70 80
this：注意
- 不能出现自己调用自己—死循环
- 相互调用不行–死循环
- 必须放在第一行
构造代码块和静态代码块
-
静态代码块:随着类的加载而加载,在整个程序执行过程中只执行一次,执行顺序优先于main
-
构成:static+{}
-
作用:对类进行初始化
-
构造代码块:随着对象的加载而加载,每次创建对象的时候都会执行一次,执行顺序优先于构造方法.
-
构成:{}
-
作用:对对象进行初始化
静态代码块优先级（只执行一次）> 构造代码块 > 构造函数
封装性
1.对属性的封装增加安全性、复用性、可读性。
2.get set 方法 规范。开发框架时会用到。
继承
1.继承 是多态的基础。Object类没有父类。
2.父类当中的private 子类得不到。
3.继承中方法调用过程：首先找自己 ，然后找父类，一直到Object，找到为止。
4.super 专门调用父类的方法 在子类中重写方法时调用super（如果父类里还有有用的）
5.重写时 返回值类型可以是父子关系 子类返回值是父类返回值的子类。
6.构造方法：子类构造方法要先调用父类构造方法，因为不对父类属性进行初始化，子类就调用不到父类的属性（属性不初始化不能调用），所以在第一行就得调用父类的构造方法（同 this）。
day03
final关键字
- 在定义时必须初始化，否则后期没法写值了。修饰类，变量，方法。π
- 空白 final 成员变量 中 final的变量值赋值 可以推迟到People构造方法技结束之前。
- String类被final修饰 。
abstract关键字
- 不能直接创建对象，对象里方法都没方法体。
- 抽象类介于类和接口之间。制定规则。
- abstract关键字 和 final static private等不能并用。
- 可以实现类里的抽象方法，也可以把自己变成抽象的。
接口
-
成员变量 默认修饰 public final static。成员方法默认修饰public abstract。
-
接口默认就是抽象的。
-
接口底层就是个类。
-
接口多实现 实现多个接口 “，”分开。补充类的单继承
-
类如果多继承那么父类里有同名方法 子类不知道选哪个 。而接口的方法没有方法体，实现时直接实现两个接口的。
-
接口作为父类的补充。
-
jdk1.7开始 接口里有方法的实现 但是必须用static和default修饰。
-
为什么：接口里的方法子类必须都得实现 接口更常用 接口更强大更灵活，但是现在还使用第一功能 。多继承。
要是都实现了呢，子类选什么：同名方法有实现（哪怕一个）了就重写，除非方法名只存在一个。
-
面向接口编程：每个类都有接口 类封起来 只调用接口用。
设计模式
- 前人解决常见问题的解决方案，后人直接拿来用。
- 单例：
-
一个类只允许有一个对象。供全局访问。用户拿到唯一一个
-
构造方法私有化 private
-
类里头创建（new）一个对象 pfs 必须private 否则类名就点到了。不想变所以final ，在这里创建两个对象违背单例的思想。
-
通过公共静态方法 必须静态 此时还创建不了对象 只能通过类名。
-
同时对象也得静态 静态方法里必须静态成员变量。
饿汉：直接实例化。
懒汉 ：用的时候实例化。不能final final完只能null了 注意要有if 否则谁用谁来new 注意：有线程安全问题。
把地址存起来 间接把唯一对象长久保存下来 不让垃圾回收，静态方法区老有一个指向地址，否则用户用完就没了
对象全局化 方法也全局了 非静态属性也全局了。
高内聚低耦合：通过单例起到连接各类 两个类却不互相关联影响。
应用：Runtime类 通过getRuntime（）获取当前运行时，应用不能创建自己的Runtime实例。
严谨的单例会把clone方法重写 。保证单一
package com.qf.singleInstance; /* * 第一种方法: * 让董事局主席类即充当单例类又作为董事局主席这个人 */ class ChairMan{ //作为单例的功能 private static ChairMan chairMan = null; private ChairMan() { } public static ChairMan getChariMan() { if (chairMan == null) { chairMan = new ChairMan(); } return chairMan; } //作为董事局主席这个人的功能 String name; String sex; int height; int weight; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } public void show(){ System.out.println("马云的信息"); } } class Demo2 //深圳 { public static void shenzhen() { ChairMan chairman=ChairMan.getChariMan(); //第二次使用单例类--直接调取值出来使用 chairman.show(); } } class Demo3 //哈尔滨 { public static void shanghai() { ChairMan chairman=ChairMan.getChariMan(); //第三次使用单例类--直接调取值出来使用 chairman.show(); } } public class Demo1 //公司总部 { public static void main(String[] args) { ChairMan chairman=ChairMan.getChariMan(); //第一次使用单例类--首先完成赋值 chairman.setName("马云"); chairman.show(); //这里是为了实现程序的模拟跳转 Demo2.shenzhen(); Demo3.shanghai(); } }
多态
- 继承是多态的前提。
- 继承要使用子类 使用父类创建对象就出问题了。
- 父（间接父类也行）类的引用指向子类的对象。
- 编译 点击三角之后是运行阶段
- 编译阶段只识别等号前面的引用 运行才识别后面的对象？？？？？8
- 缺点：不能直接调用子类的独有方法。
- 优点：提高代码的扩展性 ？？？？？？？？？？？？？？？？？？
public static void feedAnimal（Animal animal）{
animal.eat（）；//每个类都有eat方法 ？？？？？？？9
}
- object 里头方法参数也是最高级的object 不能被限制到 ？？？？？？8
-
向上转型 student-> persion
-
向下转型 persion->student 调用子类的方法
-
二者都要在多态的环境里来讲。
-
错误案例：Student persion =new persion；
persion person = new person（）；
Student Student =（Student） person（）；
-
动态的实现手段：动态类型 动态绑定 动态加载
动态加载：person person = new student（）；
动态类型：object var
动态绑定：加载动态库 静态库
-
instance of ：确定当前对象是否是后面对象的子类
-
Demo 11？？？？？？？？？？？？？？？？？？
-
前后没有继承关系 直接报错
-
成员变量 继承下子类会把父类的重写 。多态下调用父类和子类同名的成员变量 编译能能通过看父类的 运行也看父类 demo12？？？？？
Object类
-
**clone（）**创建并返回次对象的一个副本
想要使用本方法完成克隆，必须实现Cloneable接口
？？？？？？？？？？？？？？？？？？？？？？？？？？？
person里有dog 想属性深拷贝 必须把dog也给深拷贝 因为太多了所以不能完全深拷贝。
-
equals（） 默认比较地址Demo13 54 方法重写 参数不能够变，重写嘛
-
finalize（）
-
**getClass（）**得到当前字节码对象 Class 所有字节码文件对象
基本的java类型（boolean、byte、int、float等）和关键字void也表示为Class对象。 car.class 、int.class 等得到的也是Class 的对象 等同于getClass（）；
-
**hashCode（）**hash码值是对象的唯一身份证 值是10进制 后integer包装成16进制
-
notify（）
-
notifyAll（）
-
**toString()**默认是“包名+类名@hash码值” 一般都要重写这个方法
-
wait()
-
wait()
-
wait()
内部类
1.定义在一个类的内部 成员变量、成员方法和内部类平级 把他当成成员变量
在成员方法里创建内部类的对象
拿到外部类点一个new 内部类
Outer.Inner inner = outer.new Inner();
导包 先执行包里的代码 一般不用 如下。
import com.qf.test.Outer.Inner; Inner inner = outer.new Inner();
作用：用内部类间接实现多继承实现 Demo14？？？？？？？
2.局部内部类 定义在一个方法里的类 demo15
四个方法 要求1可以调用34 2不可以调用 解决方法吧34放到1里头 但是方法不能嵌套 所以用类把方法包起来 就是局部内部类
作用：我们通过局部内部类实现了功能的私有化,并对方法内部的代码进行了整理,增强了代码的可读性和可操作性.
//因为函数的定义不能嵌套,所以这里要通过局部内部类实现
注意：跟局部内部类平级的成员变量会默认加final关键字，因为局部内部类可能用到成员变量 类可以创建对象 对象在堆区可能比方法生命周期更长（指向要一直存在的话） 所以成员变量得一直存在 防止出错。
Demo16？？？？？？？？？？？？？？？？？？？？？？？？？
3.静态内部类
静态内部类不一定有静态方法，有静态方法的一定是静态内部类
Out.Inn inn = new Out.Inn()；
4.匿名内部类day03 demo18
定义在一个类方法中的匿名子类对象,属于局部内部类
匿名子类对象
两种方式 使用已有的
匿名内部类对象
Day04
异常
1.异常的问题 throwable
- Error（）：严重错误。不让解决 解决不了。
- Exception（）：可捕获处理的问题。
2.Exception分类：
- 运行时异常：运行阶段抛出。数组越界 空指针异常
- 编译异常：在编译阶段抛出。
或
- 系统异常：系统提前定义好的,我们直接使用
- 自定义异常：需要我们自己定义
3.异常层层向上抛 直到遇到能处理的接收。最后会抛给JVM。
发现有多个异常时，第一个异常会把后面的中断，程序结束。
4.try里出现异常catch会立刻捕获，try后面的代码会中断。catch里会处理异常，一般写解决方案，而不是打印一下。引用e指向具体子类异常对象。可以调用e.toString。
5.异常一般 从小往大写。Exception放最下面。
6.finally必须执行的代码。catch有return 后面代码无法执行 但是finally里还能执行。
7.System.exit(0)；此时全结束 finally也不行了。
8.自定义异常：一般写编译异常。
9.throw 是告诉别人 可能发生异常
模板设计模式
可以在地址栏看到 参数 是get。
post 看不到 参数在方法体里。
包装类
字符串转数字 ：字符串必须是数值型字符串。
拆箱：value integer1.intValue（）；
装箱：一个字节范围内 两个对象用一块内存空间。
Integer in1 =100；
Integer in2 =100；
Integer in1 =1000；
Integer in2 =1000；
sout（in1==in2）；//true
sout（in3==in4）；//false
枚举
jdk1.5前没有枚举类型。用接口常量代替。
enum
enum EnumTest{//当做类 他已经默认继承类了 可以实现
First，//0
Second，//1
third,//2
Fourth//3
}
常用类
类加载器classloder 配合虚拟机生成字节码文件对象。
1.BigInteger 和BigDecimel
2.Math
System.out.println(java.lang.Math.abs(-10));//绝对值
System.out.println(java.lang.Math.cos(3.14159));//三角余弦
System.out.println(java.lang.Math.ceil(3.4));//向上取整
System.out.println(java.lang.Math.floor(3.4));//向下取整
System.out.println(java.lang.Math.random());//随机数 [0,1.0)
3.Date
枚举
默认对应的是数字.数字从0开始计数
- 枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。
- 枚举在曰常生活中很常见，例如一个人的性别只能是“男”或者“女”，一周的星期只能是 7 天中的一个等。
- 类似这种当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型
扫一扫
747
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
