1.数据类型:由低级到高级转型
- 1
- 2
- 3
- 4
- 5
2.数据类型所占字节
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
3.二进制:计算机机器计算规则
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
4. 变量
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
5.运算符
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
6.选择结构
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
/**
* while 循环
* 先判断在执行
* do while
* 不论如何 do while 至少执行一次
*/
- 1
//初始表达式只执行一次,执行语句是在条件表达式之后执行。
for(初始表达式 ; 条件表达式 ; 循环后的表达式){
System.out.println("执行语句");
}
- 1
/**
* 使用匿名对象的时候。只有在掉了对象的行为时才有实际意义
* 调用属性没任何意义,并且都会在执行完毕之后被回收
*/
- 1
/** 封装:是指隐藏对象的属性实现细节,仅对外提供公共的访问方式
* 特点:
* 1.安全性高
* 2.复用性强
* 3.便于使用
* 4.隔离变化
* 封装的原则:将不需要对外提供的内容隐藏起来,把属性隐藏,提供公共方法让其访问
*/
- 1
/**
* 静态成员变量与非静态成员变量之间的区别:
* 1.存放的位置不同
* 2.生命周期长短不同
* 3.静态成员变量生命周期比非静态成员变量长
* 什么时候使用静态:
* 1.当几个对象之间具体共享的成员的时候
* 2.当几个对像在初始化已经具备某些相同的属性或行为
* 静态的好处:节省内存(单独开辟一个空间,存静态成员),方便使用:类名.静态成员
* 坏处:访问局限性(静态区域只能访问静态成员)
* {
* 构造代码块
* }
*/
//构造代码块:对对象进行初始化,运行在构造函数之前,对象一建立,立即运行,而且只能运行一次。静态代码块优先于构造代码块
- 1
子类继承父类,就获得了父类的属性和行为(private除外)
为什么要使用继承: 1.提高代码复用性 2.为了多态的顺利进行
继承的关系是一种特殊的关系 子类 is a 父类
先有父类,再有子类,但是代码中,父类是由多个子类进行抽取得到的。
- 1
super:代表父类的对象
this :代表本类对象
特殊情况:父类和子类没有同名成员时,使用super和this都是指父类对象
加载子类的.class文件之前会优先加载父类的.class文件
- 1
当子类和父类存在同名方法的时候:重写(覆盖)
这种覆盖不是严格意义上的覆盖,父类的方法在内存中还是存在的,
只不过这时候实例化的是子类对象,只能调用自身方法
重写是为了解决:当子类对象具备和父类相同的功能,
但是功能的内容不同时,我们可以用方法的重写来重新定义子类的功能内容,并且保留了父类的方法定义。
重写:提高了代码的可扩展性
//重写与重载的区别:1.方法的重载只看参数列表 2.重写子类和父类的方法格式必须一模一样
- 1
在子类构造方法中会默认添加一个隐式语句,super();回调父类的构造函数
子类中每个构造函数都调用了一次父类的构造函数super();
为什么Java要这么干:在子类创建对象之前,必须明确父类初始化的内容,防止安全隐患
用了this(),super就不会默认被添加,因为代码最终还是会走super()。
super()必须出现在构造函数的第一行。
this()回调本类空参构造;
- 1
这个功能不能含有方法体,因为这里面的功能存在很多模糊不清的东西。
特点:abstract能够修饰类和方法,不能够修饰变量
为啥出现抽象:我们抽取的过程中发现很多子类的方法名字相同,但是实现的功能不一样,我们父类无法对其进行描述,因为它是模糊不清的,这个时候我们只抽取方法的名字,没有方法体
特征:1.抽象类不能被实例化,不能用new来创建对象
2.子类继承抽象类,子类必须重写抽象类中所有方法,不重写也行,只不过这时候子类也成了抽象类
3.要想实例化抽象类,必须实例化重写了其所有抽象方法的子类
4.子类要想真实存在,必须重写所有抽象方法,因为抽象类含有强制性
5.抽象类其实和一般类一样,都是从子类向上抽取得到的。
//不同之处在于:1.抽象类一般情况下比一般类要多几个抽象方法(HttpServlet它是一个抽象类,但是它没有抽象方法,这么做唯一的目的就是不让其进行实例化操作)。2.抽象类不能被实例化
- 1
方法都是抽象方法
成员格式固定: 成员变量:public static final
成员方法:public abstract
(修饰符可以不写,系统会默认添加)
接口和抽象类一样,不能被实例化,要想实例化接口,必须实例化一个类(实现了该接口)
在JVM中,接口的编译生成的还是.class文件。
不支持多继承的原因:父类可能含有同名方法,会出现安全隐患。但是在多实现过程中,不存这种说法,接口的方法本身就是不具备方法体,是模糊不清的,所以说实现多个接口的类不管到底实现了哪个接口的方法。
Java中可以同时进行实现接口和继承,extends XXX implements XX
接口和接口的关系:继承,可以多继承
特点:
1. 是一种对外暴露的规则
2. 接口是程序功能的扩展
3. 接口可以多继承
4. 接口与接口有继承关系:多继承
- 1
对象的多态:一种事物的多种表现形态
父类的引用指向了子类的对象
1. 多态提高了代码的扩展性
2. 使用的局限性:不能使用子类特有的方法
- 1
(编译看左边,运行看右边)
非静态方法 编译过程中:查看引用类型变量是否含有该方法
运行过程中:查看引用类型变量指向的对象方法
静态方法 编译过程和运行过程中:查看引用类型变量是否含有该方法
成员变量 编译过程和运行过程中:查看引用类型变量是否含有该变量
20.内部类:一个类定义在另一个类的内部类
访问内部类分两种情况:
1.内部类所在外部类访问
2.外部其他类访问内部类
外部类.内部类 变量名 = 外部类对象.内部类对象
(Outer.Inner in = new Outer().new Inner())
内部类可以访问外部类的所有成员,包括私有成员
不论内部类是否被封装,外部类都能进行访问
内部类的意义:1.为了让内部类对外部类所有成员具有访问权限,
2.可以对内部类进行更好的封装,要想访问内部类对象,必须经过外部类的同意(外部类可以提供一个方法供其它类进行访问)
当被static修饰的时候,可以直接使用外部类.内部类来创建对象。(Outer.Inner in = new Outer.new Inner()) 如果内部类中有静态内容,那么该类也必须是静态的
内部类中调用外部类的成员,省略了:外部类.this
作为局部变量存在,只能在当前所在区域内进行调用。不能静态化
匿名内部类其实就是一种简写格式
定义匿名内部类的前提:内部类必须继承一个类或者实现一个接口
- 1
进程:是由系统创建的一个活动单元
线程:进程运行的最小单元,是由系统创建
CPU运行线程
线程的状态:
1. 被创建
2. 运行
3. 睡眠
4. 等待
5. 阻塞
6. 销毁
- 1
使用前提:
1. 必须是多个线程
2. 必须使用同一个锁
线程锁(synchronized)
synchronized (obj){ //obj—>锁旗标
共享数据代码块
}
- 1
-
找出使用多线程运行代码
- 是否操作了共享数据
-
操作共享是否会出现安全问题
同步方法:
因为非静态方法是被对象调用的,所以这个锁就是自己对象本身this
静态方法:JVM首先将.java编译成.class,这时候.class是作为对象存在,所以使用的锁:类名.class
死锁
解决单例模式–>懒汉式线程不安全的方法。
public class Single{
private Single(){}private static Single lhs = null; public static Single getInstance(){ if(lhs == null){ synchronized (Single.class){ if(lhs == null){ lhs = new Single(); } } } return lhs; }
}
- 1
wait(),notify()。必须持有锁
必须同一个锁
线程池:1.存放等待的线程
notify():一般情况下跑到线程池去唤醒第一个等待的线程
wait(),notify(),notifyAll().这三个方法封装在Object类中的原因:
这三个方法必须持有锁,这个锁是任意对象,在调用过程中,只有Object可以作为任意对象的父类。所以封装在Object类中,可以被任意锁调用
- 1
wait()、wait(long) 或 wait(long, int) 方法,或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻。
调用Interrupt()方法则其中断状态将被清除,它还将收到一个 InterruptedException。
//join();加入,优先执行,A线程加入B线程,优先执行A线程,A线程执行完毕,执行B线程,与除AB外其他线程无关。
- 1
String str = "abc";//这样写是在常量池中开辟一个空间
String对象有一个特性:不可变(指的是对象),赋值操作是针对该对象的引用进行的,让该对象的引用指向其他内存地址
String str1 = "abc";
String str2 = new String("abc");
//区别:第一句:创建了一个对象
第二句:创建了两个对象
equals()在String中对Object的方法进行了重写,比较的是字符序列
- 1
1. 集合可以存储不同类型的数据
2. 集合长度可变
3. 集合用来存储对象,对象是用来存储数据
4. 集合里面存放的都是对象的地址
List:它是有序的,可重复的,因为他有索引
ArrayList:底层是数组结构,查询快,增删慢,它是线程不同步的
LinkedList:底层是链表结构,查询慢,增删快
Vector:底层是数组结构,它是被淘汰的
TreeSet:底层是树状结构
数据是按字典顺序排列的
- 1
/**
* 泛型:广泛的类型
* 在编写代码的过程中,使用集合强转的时候可能会出现ClassCastException(类型转换异常)
* 因为在集合中存放的对象是任意的,使用对象的时候会有安全隐患
* JDK1.5之后出现了泛型
* 1.泛型好处在于:将程序运行时的异常转换成编译时的异常
* 方便程序员编写代码,提高代码的安全性
* 2.避免了强转操作
* 泛型的格式:<类型>
* 泛型的使用:在集合中使用的比较多,其实泛型的定义就是指定接收某一类型
*
* 泛型出现之前与出现之后的对比:
* 早期:定义Object去接收未知类型
* 现在:当需要使用的引用数据类型不确定的时候,使用泛型去作为一个规则去接收数据(提高代码的扩展性)
* 一旦这么定义,该类中所有使用到了该泛型的方法都必须遵守这个规则
* 现在我想打破这个规则:
* 1.之前都是泛型类
* 2.可以使用泛型方法打破这个规则
* 当方法需要使用未知类型的引用数据的时候,如果在类上定义泛型,会造成使用的局限性,为了打破这个局限性,
* 我们在方法中单独定义泛型,让该方法使用的泛型脱离类的控制
* 格式:修饰符 <泛型> 返回值 方法名(){}
* 静态方法使用泛型:必须使用自己定义的泛型
*
* 泛型的高级应用:
* 占位符: ?
* 泛型限定: ? extends Person 定义上限,向下扩展
* : ? super Person 定义下限,向上延伸
*
*/
```
29.Map集合
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37