10.31
目录
一.构造方法
二.this关键字
1.this.data
2.this.func()
3.this()
三.代码块
1.字段的初始化
2.代码块的定义
1.普通代码块
2.构造代码块
3.静态代码块
四.匿名对象
五.总结
六.构建函数交换值
七.计算
八.算法效率
九.时间复杂度
十.空间复杂度
十一.线性表
十二 顺序表
十三实现顺序表的增删查改
十四.打印顺序表
十五.在pos位置新增元素
十六.获取某个位置元素
十七.删除元素
十八.清空表
十九.链表
二十.单向不带头非循环
一.构造方法
在用关键字new实例化新对象的时候会被自动调用,用于完成初始化操作.
new执行过程
1.为对象分配内存空间
2.调用对象的构造方法
语法规则
1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造
注意事项
如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
若类中定义了构造方法，则默认的无参构造将不再生成.
构造方法支持重载. 规则和普通方法的重载一致.
二.this关键字
this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法
我们会发现在构造函数的内部，我们可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，
我们就使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用
1.this.data
调用当前对象的属性
2.this.func()
调用当前对象的方法
3.this()
调用当前对象的其他构造方法,指存放在当前构造函数
并且只能放在第一行,并且写的是形参
三.代码块
1.字段的初始化
字段的初始化方式有：
- 就地初始化
- 使用构造方法初始化
- 使用代码块初始化
2.代码块的定义
代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块
1.普通代码块
定义在方法中的代码块.
2.构造代码块
构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。
注意事项: 实例代码块优先于构造函数执行
这里注意,构造代码块在构造函数之下,但是还是构造代码块先执行.
3.静态代码块
使用static定义的代码块。一般用于初始化静态成员属性
/只能访问静态数据成员
静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行
只能访问静态成员
如果都是静态的 谁最后定义谁对
四.匿名对象
匿名只是表示没有名字的对象.
没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对像.
//创建一个匿名对象 new Person("sun",15).print();
五.总结
class Person{
public String name;//普通成员变量
public static int age=99;//静态成员变量.不依赖对象
private String Sex;//私有成员变量 不能直接访问需要get和set方法间接
//构造方法
public Person(){//无参构造函数,没有生成的时候,编译器会默认给我们生成一个无参函数
this("name",15);
this.name="Sunyi";
this.age=15;//类里也可以直接访问私有变量.
}
public Person(String name,int age){//带有两个参数的构造函数,构造函数可以重载,取决于构建对象的时候传参数目.
//this();
this.name=name;
this.age=age;
System.out.println("我是构造方法");
}
//方法
public void print(){//普通方法
System.out.println(name+" "+"在吃饭");
}
public static void game(){//静态方法
System.out.println("game");
// print();//静态方法不依赖对象,所以不能调用普通方法
}
//.代码块
{
System.out.println("构造代码块 ");//构造代码块
}
static{
System.out.println("静态代码块");
//age=18;
//name=""
}
//编译器设置的接口
public String getSex() {
return Sex;
}
public void setSex(String sex) {
Sex = sex;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", Sex='" + Sex + '\'' +
'}';
}
}
public class TestSun {
public static void main(String[] args) {
Person person=new Person();
// person.print();
// Person.game();
//创建一个匿名对象
new Person("sun",15).print();
person.setSex("sun");
String Sex= person.getSex();
System.out.println(Person.age);
{
System.out.println(" ");//普通代码块
}
}
一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的
方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
this关键字代表的是当前对象的引用。并不是当前对象。
六.构建函数交换值
因为如果建立一个函数,随着函数的建立销毁,形参也会相应销毁,所以不可以,
在Java里我们可以在利用类创建两个对象,再传参到函数中,这里对象其实就是在堆上的引用,传的也是引用,
函数直接对引用进行操作,来进行实际交换值
代码:
变量名不允许加点,方法传参直接传对象名就行,到了方法里再进行加点引用找到对象里的东西
七.计算
两个整型相除其中一个乘以1.0变成浮点型并用浮点型变量接收
八.算法效率
算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。
九.时间复杂度
算法中的基本操作的执行次数，为算法的时间复 杂度。
二分查找的最坏情况就是不停的二分二分直到不能再二分的时候最后一个是
那么就是2^k=n.则k=log2n
十.空间复杂度
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
十一.线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见 的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储 时，通常以数组和链式结构的形式存储
十二 顺序表
概念及结构
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为：
静态顺序表：使用定长数组存储。
动态顺序表：使用动态开辟的数组存储。
静态顺序表适用于确定知道需要存多少数据的场景.
静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用.
十三实现顺序表的增删查改
public class SeqList {
// 打印顺序表
public void display() { }
// 在 pos 位置新增元素
public void add(int pos, int data) { }
// 判定是否包含某个元素
public boolean contains(int toFind) { return true; }
// 查找某个元素对应的位置
public int search(int toFind) { return -1; }
// 获取 pos 位置的元素
public int getPos(int pos) { return -1; }
// 给 pos 位置的元素设为 value
public void setPos(int pos, int value) { }
//删除第一次出现的关键字key
public void remove(int toRemove) { }
// 获取顺序表长度
public int size() { return 0; }
// 清空顺序表
public void clear() { }
}
比十四.打印顺序表
public void displayList(){
for (int i = 0; i < usedSize; i++) {
System.out.print(elem[i]+" ");
}
}十五.在pos位置新增元素
1.先判断pos有没有越界
2.再判断数组是否满了,不然后期会导致数组越界
3.把元素移后面一位
4添加元素,并让有效数字加1
*//打印顺序表 public void displayList(){ for (int i = 0; i < usedSize; i++) { System.out.print(elem[i]+" "); } } //获取顺序表的长度 public int size(){ return this.usedSize; } //在POS位置新增元素 public void addElem(int pos,int data){ //判断pos位置是否合法 if(pos<0||pos>usedSize){ System.out.println("位置不合法"); return; } //判断数组满了没有 if (isFull()) { this.elem= Arrays.copyOf(elem,elem.length*2); } //先把pos位置开始的元素顺序往后移一位 if(isFull()) { this.elem = Arrays.copyOf(this.elem,2*this.elem.length); } //放置数据.并把有效元素加1; elem[pos]=data;usedSize++; } public boolean isFull() { return this.usedSize == this.elem.length; }
十六.获取某个位置元素
1.判断是否合法
2.判断是否是空的,这里很重要,不然会直接得到一个元素没有初始化过得
*// // 获取 pos 位置的元素
public int getPos(int pos){
if(pos<0||pos>usedSize){
System.out.println("位置不合法");
return -1;
}
if(isEmpty()){//要判断是否空的,不然是空的,会造成数组越界
System.out.println("为空");
return -1;
}
return this.elem[pos];
}
public boolean isEmpty(){
if(usedSize==0){
return true;
}
return false;
}十七.删除元素
1.看是否是空的
2.查找
3.把最后一个元素依次往前移一位 并且有效元素减1
这里注意如果是引用数据类型,需要把最后一个设置为null;
public void dele(int k){
if(isEmpty()){
return;
}
int i=0;
for (i = 0; i < usedSize; i++) {
if(elem[i]==k){
break;
}
}
if(i==usedSize){
System.out.println("没有找的数字");
return;
}
for (int j = usedSize; j>i; j--) {
elem[j-1]=elem[j];
}
this.usedSize--;//如果是引用数据类型需要 this.usedSize=null;
}十八.清空表
//清空顺序表
public void clear(){
this.usedSize=0;
//如果是引用数据类型
/* for (int i = 0; i < usedSize; i++) {
this.elem[i]=null;
}
this.usedSize=0;*/
}十九.链表
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的
分为八种
链表是由一个个的节点组成
二十.单向不带头非循环
head里面存储的就是第一个节点(头节点)的地址
head.next存储的就是下一个节点的地址
尾结点他的next是个null
单向 不带头,循环
双向 不带头 非循环
