- 进程:就是正在运行的应用程序.进程负责了内存空间的划分.
- 线程:一个进程中的代码是由线程去执行的,线程就是进程中的一个执行路径.
-
- 多线程:一个进程中有多个线程可以同时执行任务.
- 多线程的好处:1.解决一个进程中可以同时执行多个任务的问题.2.提高了资源利用率.
- 多线程的弊端:1.增加了CPU的负担;2.降低了一个进程中线程的执行概率;3.出现了线程安全问题;4.会引发死锁现象.
- 自定义线程的实现方式:
- (一):1.自定义一个类,继承Thread类;2.重写Thread类的run方法,把自定义线程的任务代码写在run方法里;3.创建Thread类的子类对象,并且调用Start方法启动一个线程;(注意:千万不要直接调用run方法,调用start方法的时候线程就会开启,线程一旦开启就会执行run方法中的代码.如果直接调用run方法,那么就相当于调用了一个普通的方法而已.)
- (二):同步函数
- 线程安全问题出现的根本原因:1.存在两个或两个以上的线程对象,共享同一个资源;2.多线程操作共享资源的代码有多条.
- 解决方法:1.使用同步代码块解决:
- 格式:synchronized(锁对象){
需要被同步的代码;
}
- 注意:1.锁对象可以是任意的一个对象;2.一个线程在同步代码块中sleep了,并不会释放锁对象;3.如果不存在线程安全问题,千万不要使用同步代码块,会降低效率;3.锁对象必须是多线程共享的一个资源,否则锁不住.
# final关键字
- 1.final关键字修饰一个基本类型的已初始化的变量时,该变量不能重新赋值,第一的值就是最终的值,不可修改;2.修饰一个引用类型变量时,该变量不能重新指向新的变量;3.修饰一个函数的时候,该函数不能再被子类重写;4.修饰一个类的时候,该类不能被继承.
## 常量:public static final XX=?;
## 不同方法上面的局部变量是相互独立的,没有任何关系.(只是同名而已);方法中的形参也属于该方法的局部变量.
# 抽象类abstract
- 如果一个函数没有方法体,那么该函数必须使用abstract修饰,把该函数修饰成抽象的函数.(只有方法声明,没有方法实现);2.如果一个类中出现了抽象的函数,那么该类也必须使用abstract修饰;3.如果一个非抽象类继承了抽象类,那么非抽象类必须把抽象类的所有抽象方法全都实现;4.抽象类中可以存在非抽象的方法;也可以不存在抽象方法(此时该类实质上不是抽象类);5.抽象类中不能创建new对象;(WAY?因为抽象类是存在抽象方法的,如果能让抽象类创建对象的话,使用抽象的对象调用抽象的方法是无意义的);6.抽象类是存在构造函数的,其构造函数是提供给其子类创建对象的时候初始化父类的属性的;
- 应用场景:我们在描述一类事务的时候,发现该事物确实存在着某种行为,但是这种行为目前是不具体的,那么我们可以抽取这种行为的声明,但是不去实现该行为,这时候这种行为我们称为抽象的行为,我们就需要使用抽象类.
- 抽象类的好处: 强制要求子类一定要实现抽象类中指定的抽象方法.(因为不全部实现抽象类中的方法会报错);
# 多态
- 概念:同一个对象,在不同的时刻,体现出来的,不同的状态
- 前提条件:
- 有父类或接口
- 有继承或实现的关系
- 有非法的重写
- 分类:
- 具体类继承的多态
class Fu { }
class Zi extends Fu { }
Fu f = new Zi;
- 抽象类继承的多态
abstract class Fu { }
class Zi extends Fu { }
Fu f = new Zi;
- 接口实现的多态
interface Fu { }
class Zi implements Fu { }
Fu f = new Zi;
- 多态中的成员访问特点
- 成员变量与静态方法:
编译看左边,运行也左边;
- 成员方法:
编译看左边,运行看右边;
(因为成员方法有重写,所有运行时以子类为主)
- 多态的好
- 提供代码的维护性(继承体现)
- 提高代码的扩展性(多态体现)
- 多态的弊
- 父不能使用子的特有功能
现象:
子可以当作父使用,父不能当作子使用;
- 多态中的转型
- 向上转型
从子到父
- 向下转型
从父到子
# 抽象类
- 把多个类中的共性的东西,提取到一个类中,此类设为父类,者是继承;但是,这多个共性的东西,在有些时候,方法声明一样,但是方法体具体行为不一样/所以,我们在定义这些共性的方法是时候,就不能给出具体的方法体/而一个没有具体方法体的方法是抽象的方法/在一个类中,如果有抽象方法,该类必须定义为抽象类.
- 抽象类的特点
- 抽象类和抽象方法必须用关键字abstract修饰
- 抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
- 抽象类不能实例化
- 抽象类的子类
- 是一个抽象类
- 是一个具体类,这个类中必须重写抽象类中的所有抽象方法.
- 抽象类的成员特点
- 成员变量
有变量,有常量,
- 构造方法
有构造方法.
- 成员方法
有抽象,有非抽象
- 问题:
- 抽象类有构造方法,但不能实例化,那么构造方法有什么用?
答:用于子类访问父类数据的初始化.
- 一个类如果没有抽象方法,却定义为了抽象类,有什么用?
答:为了不让外部创建此类对象
- abstract不能喝哪些关键字共存?
答:final,private,static
# 接口
- 接口是用来表示对象额外新增的行为功能的,此功能不是与生俱来的,是后天培养的.
- 接口的特点
- 接口用关键字interface修饰
interface 接口名 { }
- 类实现接口用implements修饰
class 类名 implements 接口名 { }
- 接口不能实例化
- 接口的实现类
- 是一个抽象类
- 是一个具体类:这个类中必须重写该接口中所有的抽象方法.
- 接口的成员特点
- 成员变量
只能是常量
因为默认修饰符是 public static final
- 成员方法
只能是抽象的方法
因为默认修饰符是 public abstract
- 构造方法
没有构造方法.
- 关系
- 类与类 / 继承关系
- 只能单继承,但可以多层继承 (一个子类只能继承一个父类,但可以继承父类的父类)
- 类与接口 / 实现关系
- 可以单实现,也可以多实现.
- 还可以在继承一个类的同时,实现多个接口
- 接口与接口 / 继承关系
- 可以单继承,也可以多继承
- 抽象类与接口的区别
- 成员区别:
抽象类:
接口:
- 关系区别:
类与类
类与接口
接口与接口
- 设计理念不同
抽象类:is a,抽象类定义的是共性行为功能
接口: like a,接口类定义的是扩展行为功能
------------------------------------------------------------
# DAY 10
## 形式参数与返回值
- 形式参数:
- 类名:需要该类的对象
- 抽象类名: 需要该类的子类对象
- 接口名: 需要该接口的实现类对象
- 返回值类型:
- 类名: 返回该类的对象
- 抽象类名: 返回该类的子类对象
- 接口名: 返回该接口的实现类对象
- 链式编程:
- 格式: 对象.方法1().方法2()......方法n();
这种用法:其实在方法1调用完毕后,应该返回一个对象;方法2调用完毕后,应该返回一个对象;
方法n调用完毕后,可能是对象,也可能不是对象.
## 包
- 是什么?
- 其实就是文件夹.
- 作用
- 区分同名的类
- 对垒进行分类管理
- 按照功能分,按照模块分.
- 包的定义
- package 包名;
- 多级包用.分开
- 注意事项
- package语句必须在文件中的第一条有效语句
- 在一个java文件中,只能有一个package
- 如果没有package,其实默认就是无包名
- 带包的编译与运行
- 手动式
- 自动式: javac -d . HelloWorld.java
- 导包
- 我们多次使用一个带包的类,非常的麻烦,这个时候,java就提供了一个关键字improt
- 格式: improt 包名...类名;
- 顺序: package > improt > class
## 权限修饰符
本类 同一个包下 不同包下的子类 不同包下无关类
- private Y
- 默认 Y Y
- protected Y Y Y
- public Y Y Y Y
- 这四种权限修饰符,在任何时候只能出现一种
- 常见的修饰符
- 分类
- 权限修饰符: private,默认,protected,public
- 状态修饰符: static,final
- 抽象修饰符: abstract
- 常见的类及其组成的修饰
- 类: 默认,public,final,abstract
常用的: public
- 成员变量: private,默认,protected,public,static,final
常用的: private
- 构造方法: private,默认,protected,public
常用的: public
- 成员方法: private,默认,protected,public,static,final,abstract
常用的: public
- 另外比较常见的:
- 静态常量: public static final int x=10;
- 静态方法: public static void show(){ }
- 最终方法: public final void show(){ }
- 抽象方法: public abstract void show(){ }
## 内部类
- 是什么?
- 把类定义在另一个类的内部,该类就称为内部类.
- 访问规则:
- 可以直接访问外部类的成员,包括私有的
- 外部类要想访问内部类成员,必须常见对象
- 分类: 成员内部类 与 局部内部类
- 成员内部类的修饰符:
- private 为例数据的安全性
- static 为了访问的方便性
成员内部类不是静态的时候:
- 外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
成员内部类是静态的时候
- 外部类名.内部类名 对象名 = new 外部类名.内部类名();
- 面试题
class Outer{
public int num = 10; //类的成员变量
class Inner{
public int num = 20; //成员内部类的成员变量
public void show(){
int num = 30; //局部变量
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(Outer.this.num); //10
}
}
}
- 局部内部类
- 局部内部类访问局部变量必须加final修饰
- 因为几部变量使用完毕就消失,二堆内存的数据并不会立即消失.所以,此时堆内存还要使用该变量,然而该变量已经消失了.为了让该值还存在,就加final修饰.通过反编译工具我们看到了,加了final修饰后,堆内存直接存储的是值,而不是局部变量名.
- 匿名内部类
- 是什么
- 是局部内部类的简化形式
- 前提:存在一个(抽象)类或者接口
- 格式: new 类名或者接口名(){
重写方法;
}
- 本质: 是继承该类或者实现该接口的子类的匿名对象.(是一个对象,而不是类)
- 匿名内部类在开发中的使用
- 当抽象类或者接口作为方法的参数时,如果该方法只会调用一次,我们就可以使用匿名内部类的格式简化子类对象的调用.
## 面试题
Interface Inter{
void show();
}
class Outer{
//补齐代码
public static Inter method(){
return void Inter(){
public void show(){
System.out.println("HelloWorld");
}
}
}
class OuterDemo{
public static void main(String[] args){
Outer.method().show(); //输出了"HellWorld"
}
}
-----------------------------------------------------------------------
# DAY 11
## API的概述
- 应用程序的编程接口
- 就是JDK提供给我们的一些提高编程效率的java类
## Object类
- 是什么
- Object是类层次的结构的跟类,所有的类都直接或者间接的继承自Object类
- Object类的构造方法有一个,并且是无参构造
- 子类构造方法默认访问父类的构造是无参构造
- 主要方法
- toString(); //返回该对象的字符串表示,默认是由类的全路径+'@'+哈希值的十六进制表示,其实无意义,一般子类都会重写该方法
- equals(Object o); //比较两个对象是否相同.默认比较地址值是否相同.一般子类也会重写该方法.
- 其他方法
- hashCode(); //返回给对象的哈希值.不是实际地址值,可以理解为地址值(门牌号)
- getClass(); //返回该对象的反射类(.class字节码文件对象)
- finalize(); //垃圾回收器,在不确定的时间,无意义
- clone(); //创建并返回对象的一个副本.可以实现对象的克隆,包括成员变量的数据复制,但是它和两个应用指向同一个对象是有区别的.
- 注意
- 直接输出一个对象名称,其实默认调用了该对象的toString()方法.
- 面试题
==和equals()的区别?
1.==
- 基本类型比较: 比较值是否相同;
- 引用类型比较: 地址值是否相同;
2.equals()
- 只能比较引用类型.因为基本类型不能调用方法.
- 默认情况下比较的是地址值是否相同,但是可以根据自己的需要重新改方法.
---------------------------------------------------------------------
# DAY 12
## Scanner的使用
- 在JDK5一行出现的,用于键盘录入数据的类
- 在构造方法里,System.in是个标准的输入流,对应键盘的录入
- 构造方法常用的格式
Scanner sc = new Scanner(System.in);
- 基本方法格式
- hasNextXXX() 判断是否是某种类型的
- nextXXX() 返回某种类型的元素
- 常用方法
- public int nextInt(); //获取int类型数据
- public String nextLine(); //获取字符串类型数据
- 注意
- 同一个Scanner对象,先获取数值,再获取字符串会出现一个小问题.
解决方案:1.重新定义一个Scanner对象;2.把所有的数据都用字符串获取,然后在镜像想要的额转换.
## String类的概述个使用
- 是什么
- 多个字符组成的数据
其实可以和字符数组进行相互的转换
- 构造方法
1.public String();
2.public String(各种参数)
3.String s = "Hello"; //虽然不是构造方法,但是结果也是字符串对象
- 字符串的特点
- 字符串一旦被赋值,就不能被改变
- 指的是内容不能改变,而不是引用不能改变
- 字面值作为字符串对象,和通过构造方法创建对象的不同?
String s = new String("Hello");和String s = "Hello"的区别
答:前边在方法区与堆上都有;后边只在方法区上有.
- 面试题
1.==和equals()
- 有new则FT,无new全T.
String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1==s2); //false,
System.out.println(s1.equals(s2); //true,在堆上的地址相同
String s3 = new String("Hello");
String s4 = "Hello";
System.out.println(s3==s4); //false,
System.out.println(s3.equals(s4)); //true,
String s5 = "Hello";
String s6 = "Hello";
System.out.println(s5==s6); //true,
System.out.println(s5.equals(s6)); //true,
2. 字符串的拼接时==与equals()比较
- 有对象间的拼接则FT,无对象拼接无new则全T.
- 字符串的功能
- 判断
- .equals(obj)
- .equalsIgnoreCase(str)
- .contains(str)
- .startsWith(str)
- .endsWith(str)
- .isEmpty()
- 获取
- .length()--int
- .charAt(int index)--char
- .indexOf(各种参数)--int
- .substring(int start)--String
- .substring(int start,int end)--String
- 转换
- getBytes()--byte[]
- toCharArray()--char[]
- valueOf()--static String
- toLowerCase()--String
- toUpperCase()--String
- concat(str)--String
- 其他
- 替换
- replace(char old,char new)--String
- replace(String old,String new)--String
- 去除空格
- trim()--String
- 按字典比较
- compareTo(str)--int
- compareToIgnoreCase(str)--int
- ---------------------------------------------------------------
# DAY 13
## StringBuffer
1.用字符串做拼接,比较耗时耗内存;所有java提供了一个字符串缓冲区类--StringBuffer.
2.构造方法:
- StringBuffer()
- StringBuffer(int size)
- StringBuffer(String str)
3.常见功能
-添加
- append(String str) 将指定的字符串追加到此字符序列。
- insert(int offset, Object obj)
将 Object 参数的字符串表示形式插入此字符序列中。
-删除
- delete(int start, int end)
移除此序列的子字符串中的字符。
-替换
- replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。
-反转
- reverse()
将此字符序列用其反转形式取代。
-截取(返回值为String)
- substring(int start, int end)
返回一个新的 String，它包含此序列当前所包含的字符子序列。
##数组高级以及Arrays
- 冒泡排序
- 相邻元素亮亮比较,大的往后放,第一次完毕,最大值出现在了最大索引处.同理,其他的元素就可以排好.
public static void bubblesort(int[] arr){
for(int x=0,x<arr.length-1;x++){
for(int y=0;y<arr.length-1-x;y++){
if(arr[y] > arr[y+1]){
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
- 选择排序
- 把0索引的元素,和索引1以后的元素都进行比较,第一次完毕,最小值出现在了0索引处.
public static void selectsort(int[] arr){
for(int x=0,x<arr.length-1;x++){
for(int y=x;y<arr.length;y++){
if(arr[y] < arr[x]){
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
2.查找
- 基本查找 (针对数组无序的情况)
public static int getIndex(int[] arr,int value){
int index =-1;
for(int x=0;x<arr.length;x++){
if(arr[x]==value){
index = x;
break;
}
}
return index;
}
- 二分查找 (针对数组有序的情况,千万不要先排序在查找)
public static int binarySearch(int[] arr,int value){
int min=0;
int max=arr.length-1;
int mid=(min+max)/2;
while(arr[mid] !=value){
if(arr[mid] > value){
max=mid-1;
}else if(arr[mid] < value){
min mid+1;
}
if(min>max){
return -1;
}
mid = (max+min)/2;
}
return mid;
}
3.Arrays工具类
- 是针对数组进行操作的工具类,包括排序和查找等功能.
- 方法:
- 把数组转成字符串
- toString(Object[] a)
返回指定数组内容的字符串表示形式。
- 排序
- sort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。
- equals(Object[] a, Object[] a2)
如果两个指定的 Objects 数组彼此相等，则返回 true。
- 二分查找
- binarySearch(T[] a, T key, Comparator<? super T> c)
使用二分搜索法来搜索指定数组，以获得指定对象。
## Integer
- 为了让基本类型的数据进行更多的操作,java就为每种基本类型提供了对应的包装类型.
- bate/Byte - short/Short - int/Integer - long/Long - float/Float - double/Double - char/Character - boolean/Boolean
- Integer的构造方法:
- Integer i = new Integer(100);
- Integer i = new Integer("100");
注意:这里的字符串必须是由数字字符组成的
- String 与 int 的相互转换:
- String转int:
Integer.parseInt("100");
- int转String:
String.valueOf(100);
## Character
# 递归
- 在方法定义中调用方法本身的现象(不提倡使用)
- 注意事项:1.一定要向已知方向递归,明确递归出口,否则就会无穷递归.2.次数不能过多,否则内存溢出.3.构造方法不能递归使用.
public class demo{
int x = 1;
public static void main(String[] args){
System.out.println(jiec(10));
}
public statac Long jiec(int x){
if(x<2){
return "1";
}
return x*jiec(x-1);
}
}
# 重载
- 在同一个类里,声明多个同名但不同参数的方法,就是方法的重载.(空参构造与带参构造)
# IO流
- 用于在设备间进行数据传输的操作
- 分类:
- 流向
- 输入流: 读取数据
- 输出流: 写出数据
- 数据类型
- 字节流
- 字节输入流 InputStream
- FileInputStream
- BufferedInputStream
- 方法
- int read():一次只读取一个字节
- int read(byte[] bys):一次读取一个字节数组
- 字节输出流 OutputStream
- FileOutputStream
- BufferedOurputStream
- 方法
- void write(int by)
- void write(byte[] bys,int index,int len);
- 字符流 (转换流,字节流+编码表)
- 字符输入流 Reader
- InputStreamReader
- FileReader
- BufferedReader
- String readLine():一次读取一个字符串
- 字符输出流 Writer
- OutputstreamWriter
- FileWriter
- BufferedWriter
- void newLine()写一个换行符
- void write(String line):一次写一个字符串
- 注意:
- 如果没有明确说明按照什么分,默认按照数据类型分.
- 除非文件用windows自带的记事本打开我们能够读懂,才采用字符流,否则建议使用字节流.
- FileOutputStream写出数据
- 操作步骤
- 创建字节输出流对象
- 调用write()方法
- 释放资源
- 代码体现:
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("hello".getBytes());
fos.close();
- FileInputStream读取数据
- 操作步骤
- 创建字节输入流对象
-调用read()方法
-释放资源
- 代码体现
FileInputStream fis = new FileInputStream("fos.txt");
//方式1
int by = 0;
while((by=fis.read())!= -1){
System.out.print((char)by);
}
fis.close();
//方式2
byte[] bys = new byte[1024];
int len = 0;
while((len=fis.read(bys))!= -1){
System.out.print(new String(bys,0,len));
}
fis.close();
# httpclient
- 等同于浏览器,用于把不同客户端的请求数据转为json数据去service访问DB数据库.
3543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
