学习mybatis之前先复习下相关的javaj知识
例如：private static final String CONFIG="mybatis-config.xml";
1 private
访问权限 类 包 子类 其他包
public ∨ ∨ ∨ ∨
protect ∨ ∨ ∨ ×
default ∨ ∨ × ×
private ∨ × × ×
2 static final###01final关键字概念
* A: 概述
继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，
或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，
就可以对其中的方法进行重写，那怎么解决呢？
要解决上述的这些问题，需要使用到一个关键字final，final的意思为最终，不可变。
final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。
###02final修饰类义
* A: final 修饰类
final修饰类不可以被继承，但是可以继承其他类。
* B: 案例
class Yy {}
final class Fu extends Yy{} //可以继承Yy类
class Zi extends Fu{} //不能继承Fu类
###03final修饰方法
* A: final修饰方法
final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。
* B: 案例
class Fu {
// final修饰的方法，不可以被覆盖，但可以继承使用
public final void method1(){}
public void method2(){}
}
class Zi extends Fu {
//重写method2方法
public final void method2(){}
}
###04final修饰局部变量
* A:修饰基本数据类型变量
final修饰的变量称为常量，这些变量只能赋值一次
* B:案例1
final int i = 20;
i = 30; //赋值报错，final修饰的变量只能赋值一次
* C: 修饰引用数据类型
引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改
* D: 修饰引用数据类型
final Person p = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p，所记录的地址值不能改变
p.name = "小明";//可以更改p对象中name属性值
p不能为别的对象，而p对象中的name或age属性值可更改。
###05final修饰成员变量
* A: 修饰成员变量
修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)
* B: 案例
class Demo {
//直接赋值
final int m = 100;
//final修饰的成员变量，需要在创建对象前赋值，否则报错。
final int n;
public Demo(){
//可以在创建对象时所调用的构造方法中，为变量n赋值
n = 2016;
}
}
###06static的概念
* A：概念
当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。
当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。
可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。
==============================第二节课开始====================================
###07static修饰的对象特有数据
* A：特点1:
被static修饰的成员变量属于类，不属于这个类的某个对象。
（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，
其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
* B: 代码演示
class Demo {
public static int num = 100;
}
class Test {
public static void main(String[] args) {
Demo d1 = new Demo();
Demo d2 = new Demo();
d1.num = 200;
System.out.println(d1.num); //结果为200
System.out.println(d2.num); //结果为200
}
}
###08static的内存图
* A: 略
参考day13_source 静态的内存图.jpg
###09static注意事项_静态不能直接调用非静态
* A: 注意事项
被static修饰的成员可以并且建议通过类名直接访问。
* B: 访问静态成员的格式：
类名.静态成员变量名
类名.静态成员方法名(参数)
对象名.静态成员变量名 ------不建议使用该方式，会出现警告
对象名.静态成员方法名(参数) ------不建议使用该方式，会出现警告
* C: 代码演示
class Demo {
//静态成员变量
public static int num = 100;
//静态方法
public static void method(){
System.out.println("静态方法");
}
}
class Test {
public static void main(String[] args) {
System.out.println(Demo.num);
Demo.method();
}
}
###10static静态的使用场景
* A: 使用场景
static可以修饰成员变量和成员方法。
什么时候使用static修饰成员变量？
加static修饰成员的时候，这个成员会被类的所有对象所共享。一般我们把共性数据定义为静态的变量
什么时候使用static修饰成员方法？
静态的方法只能访问静态的成员，如果静态方法中引用到了静态的其他成员，那么这个方法需要声明为静态的方法。
###11对象中的静态调用
* A: 对象的静态调用
在多态中，非静态编译看父类，运行看子类，父类没有编译失败。
但多态中的静态方法,编译看父类,运行仍然看父类。因为静态和对象没有关系，属于静态绑定。
* B: 举例
public class Test{
public static void main(String[] args){
Fu f = new Zi();
f.show(); //父类的引用和父类的方法绑定,和对象无关,不会在运行时动态的执行子类特有的方法。
}
}
###12定义静态常量
* A: 静态常量
开发中，我们想在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义。
此时变量名用全部大写，多个单词使用下划线连接。
* B: 定义格式：
public static final 数据类型 变量名 = 值;
* C: 如下演示：
class Company {
public static final String COMPANY_NAME = "传智播客";
public static void method(){
System.out.println("一个静态方法");
}
}
当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。
System.out.println(Company.COMPANY_NAME); //打印传智播客
Company.method(); // 调用一个静态方法
* D: 注意：
接口中的每个成员变量都默认使用public static final修饰。
所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。
interface Inter {
public static final int COUNT = 100;
}
访问接口中的静态变量
Inter.COUNT
3
4
数据的存储结构
A:数据的存储结构
a:栈结构:后进先出/先进后出(手枪弹夹) FILO (first in last out)
b:队列结构:先进先出/后进后出(银行排队) FIFO(first in first out)
c:数组结构:
查询快:通过索引快速找到元素
增删慢:每次增删都需要开辟新的数组,将老数组中的元素拷贝到新数组中
开辟新数组耗费资源
d:链表结构
查询慢:每次都需要从链头或者链尾找起
增删快:只需要修改元素记录的下个元素的地址值即可不需要移动大量元素
5
01List接口的特点
A:List接口的特点:
a:它是一个元素存取有序的集合。
例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
b:它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
c:集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
d:List接口的常用子类有：
ArrayList集合
LinkedList集合
###02List接口的特有方法
A:List接口的特有方法(带索引的方法)
a:增加元素方法
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e) 向集合指定索引处，添加指定的元素，原有元素依次后移
/*
* add(int index, E)
* 将元素插入到列表的指定索引上
* 带有索引的操作,防止越界问题
* java.lang.IndexOutOfBoundsException
* ArrayIndexOutOfBoundsException
* StringIndexOutOfBoundsException
*/
public static void function(){
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
list.add(1, "itcast");
System.out.println(list);
}
b:删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
/*
* E remove(int index)
* 移除指定索引上的元素
* 返回被删除之前的元素
*/
public static void function_1(){
List<Double> list = new ArrayList<Double>();
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double d = list.remove(0);
System.out.println(d);
System.out.println(list);
}
c:替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
/*
* E set(int index, E)
* 修改指定索引上的元素
* 返回被修改之前的元素
*/
public static void function_2(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Integer i = list.set(0, 5);
System.out.println(i);
System.out.println(list);
}
d:查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素
6
01List接口的特点
A:List接口的特点:
a:它是一个元素存取有序的集合。
例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
b:它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
c:集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
d:List接口的常用子类有：
ArrayList集合
LinkedList集合
###02List接口的特有方法
A:List接口的特有方法(带索引的方法)
a:增加元素方法
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e) 向集合指定索引处，添加指定的元素，原有元素依次后移
/*
* add(int index, E)
* 将元素插入到列表的指定索引上
* 带有索引的操作,防止越界问题
* java.lang.IndexOutOfBoundsException
* ArrayIndexOutOfBoundsException
* StringIndexOutOfBoundsException
*/
public static void function(){
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
list.add(1, "itcast");
System.out.println(list);
}
b:删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
/*
* E remove(int index)
* 移除指定索引上的元素
* 返回被删除之前的元素
*/
public static void function_1(){
List<Double> list = new ArrayList<Double>();
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double d = list.remove(0);
System.out.println(d);
System.out.println(list);
}
c:替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
/*
* E set(int index, E)
* 修改指定索引上的元素
* 返回被修改之前的元素
*/
public static void function_2(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Integer i = list.set(0, 5);
System.out.println(i);
System.out.println(list);
}
d:查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素
6
数据的存储结构
A:数据的存储结构
a:栈结构:后进先出/先进后出(手枪弹夹) FILO (first in last out)
b:队列结构:先进先出/后进后出(银行排队) FIFO(first in first out)
c:数组结构:
查询快:通过索引快速找到元素
增删慢:每次增删都需要开辟新的数组,将老数组中的元素拷贝到新数组中
开辟新数组耗费资源
d:链表结构
查询慢:每次都需要从链头或者链尾找起
增删快:只需要修改元素记录的下个元素的地址值即可不需要移动大量元素
7---------------------------
###06LinkedList集合的自身特点
A:LinkedList集合的自身特点
底层采用链表结构,每次查询都要从链头或链尾找起,查询相对数组较慢
但是删除直接修改元素记录的地址值即可,不要大量移动元素
LinkedList的索引决定是从链头开始找还是从链尾开始找
如果该元素小于元素长度一半,从链头开始找起,如果大于元素长度的一半,则从链尾找起
###07LinkedList特有方法
*A:LinkedList特有方法:获取,添加,删除
/*
* LinkedList 链表集合的特有功能
* 自身特点: 链表底层实现,查询慢,增删快
*
* 子类的特有功能,不能多态调用
*/
public class LinkedListDemo {
public static void main(String[] args) {
function_3();
}
/*
* E removeFirst() 移除并返回链表的开头
* E removeLast() 移除并返回链表的结尾
*/
public static void function_3(){
LinkedList<String> link = new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.add("4");
String first = link.removeFirst();
String last = link.removeLast();
System.out.println(first);
System.out.println(last);
System.out.println(link);
}
/*
* E getFirst() 获取链表的开头
* E getLast() 获取链表的结尾
*/
public static void function_2(){
LinkedList<String> link = new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.add("4");
if(!link.isEmpty()){
String first = link.getFirst();
String last = link.getLast();
System.out.println(first);
System.out.println(last);
}
}
public static void function_1(){
LinkedList<String> link = new LinkedList<String>();
link.addLast("a");
link.addLast("b");
link.addLast("c");
link.addLast("d");
link.addFirst("1");
link.addFirst("2");
link.addFirst("3");
System.out.println(link);
}
/*
* addFirst(E) 添加到链表的开头
* addLast(E) 添加到链表的结尾
*/
public static void function(){
LinkedList<String> link = new LinkedList<String>();
link.addLast("heima");
link.add("abc");
link.add("bcd");
link.addFirst("itcast");
System.out.println(link);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
