day01 ----------------------------------------------------------------------------------------------------------------------
*
day05 ----------------------------------------------------------------------------------------------------------------------
* 数组
** 概述: 就是一个用来存储同一种数据类型的元素的一个容器
** 一维数组(掌握)
* 格式:
** 数据类型[] 数组名 = new 数据类型[数组的长度] ; (推荐使用)
** 数据类型 数组名[] = new 数据类型[数组的长度] ;
数据类型: 作用:用来限定数组中存储元素的类型
数组名: 合法的标识符
数组的长度: 作用: 用来限定数组中存储元素的个数
* 数组的初始化:
** 动态初始化 就是由我们给出数组的长度,由系统分配初始化值
* 格式: 数据类型[] 数组名 = new 数据类型[数组的长度] ; (推荐使用)
** 静态初始化 就是由我们给出初始化值,由系统分配长度
* 格式: 数据类型[] 数组名 = new 数据类型[]{元素1 , 元素2 , 元素3 , ...} ;
* 格式: 数据类型[] 数组名 = {元素1 , 元素2 , 元素3 , ...} ;
注意事项: 不能进行动静结合
* 如何获取数组的长度: 数组名.length ;
* 如何获取数组的元素: 数组名[索引] ; // 索引: 从0开始, 最大索引为arr.length - 1
* java语言的内存分配:
** 栈: 存储的都是局部变量
* 局部变量: 定义在方法声明上或者方法定义中
** 堆: 存储的都是 new 出来的东西
* 系统为每一个new出来的东西分配地址值
* 系统为每一个元素,分配默认值
byte, short , int ,long ---- 0
float , double ---- 0.0
char ---- '\u0000'
boolean ---- false
引用数据类型 ---- null
* 使用完毕以后就变成了垃圾,等待垃圾回收器对其进行回收
** 方法区(面向对象)
** 本地方法区(和系统相关)
** 寄存器(CPU)
* 两个错误
** ArrayIndexOutOfBoundsException
** NullPointerException
* 数组的常见操作:
** 遍历
** 反转
** 获取最值
** 查表法
** 基本查找
** 二维数组(了解)
* 概述: 就是一个数组 , 只不过每一个元素也是一个数组
* 定义格式:
** 第一种格式
数据类型[][] 数组名 = new 数据类型[m][n] ; (推荐使用)
数据类型[] 数组名[] = new 数据类型[m][n] ;
数据类型 数组名[][] = new 数据类型[m][n] ;
m: 表示的意思是这个二维数组中一维数组的个数
n: 每一个一维数组中元素的个数
** 第二种格式:
数据类型[][] 数组名 = new 数据类型[m][] ;
m: 表示的意思是这个二维数组中一维数组的个数
** 第三种格式:
数据类型[][] 数组名 = {{元素1 , 元素2 , ...} , {元素1 , 元素2 , ...} , {元素1 , 元素2 , ...} ,...} ;
** 如何获取二维数组的长度: 数组名.length ;
** 如何获取二维数组的元素: 数组名[m][n]; 获取二维数组中第m+1个一维数组中的第n+1个元素
* 练习题
** 遍历
** 求和
* java语言的参数传递问题
基本数据类型的参数传递,形式参数的改变对实际参数没有影响,因为传递的是具体的数值
引用数据类型的参数传递,形式参数的改变对实际参数有影响,因为传递的是地址值 ; ( String 例外)
day06 --------------------------------------------------------------------------------------------------------------------------------------------------------
* 面向对象的思想
** 就是指挥对象做事情 , 体现到代码上: 就是创建对象调用方法
** 面向对象是基于面向过程的
** 面向对象的特征:
* 封装
* 继承
* 多态
* 类和对象
** 类: 就是一组相关属性和行为的集合 ; 我们定义一个类,其实就是定义成员变量和成员方法
** 对象: 就是该事物的一个具体的体现
** 属性: 就是该事物固有的信息
** 行为: 就是该事物可以做的事情
** 类和事物的对应关系
事物 类
属性 成员变量
行为 成员方法
定义成员变量: 和之前定义变量一致 ,只不过位置不同 ; 成员变量的位置在类中方法外
定义成员方法: 和之前定义方法一样, 只不过去掉 static
** 定义学生类
** 定义手机类
* 类的使用
** 使用步骤:
1. 创建对象 ; 格式: 类名 对象名 = new 类名() ;
2. 访问成员变量 ; 格式: 对象名.变量名 ; // 前提就是这个成员变量不能被private修饰
3. 访问成员方法 ; 格式: 对象名.方法名(...) ;
* 对象内存图
** 一个对象的内存图 目的: 告诉大家我们这个对象在内存中是如何进行构建的
** 两个对象的内存图 目的: 告诉大家每 new 一次,都会在堆内存中开辟一个新的空间
** 3个引用两个对象的内存图 目的: 告诉大家栈内存中的多个引用可以指向堆内存中的同一个地址
* 方法的形式参数是类名的时候我们如何调用
** 传递对象
** 代码:
class StudentDemo {
public void function(Student s) {
s.show() ;
}
}
class Student {
public void show() {
System.out.println("Student....show................") ;
}
}
// 需求: 调用StudentDemo类中的function方法
// 1. 创建StudentDemo对象
StudentDemo sd = new StudentDemo() ;
// 2. 创建一个Student对象
Student s = new Student() ;
// 3. 调用function方法
sd.function(s) ;
* 成员变量和局部变量的区别
** 在类中的位置不同
* 成员变量: 在类中方法外
* 局部变量: 在方法声明上或者方法定义中
** 在内存中的位置不同
* 成员变量: 在堆内存中
* 局部变量: 在栈内存中
** 生命周期不同
* 成员变量: 随着对象的创建而产生,随着对象的消失而消失
* 局部变量: 随着方法的调用而产生,随着方法的消失而消失
** 默认值的问题
* 成员变量: 存在默认值
* 局部变量: 没有默认值,使用之前必须对其进行赋值
* 匿名对象
** 概述: 就是没有名字的对象
** 举例: new Student() ;
** 使用场景:
* 当仅仅调用一次方法的时候,我们就可以使用匿名对象
* 可以作为参数进行传递
* 封装(private 关键字)
** private : 是一个权限修饰符
** 可以用来修饰成员变量和成员方法
** 被 private 修饰的成员,只能在本类中访问
** 最常见的应用: 就是把成员变量通过private修饰,然后对外提供getXxx()和setXxx()方法
* this 关系
** 代表的是本类对象的一个引用 ; 谁调用我这个方法,我这个方法中的this就代表谁 ;
** 使用this关键字,我们可以区分到底访问的是局部变量还是成员变量 ; 因为变量的访问遵循一个"就近原则"
day07 --------------------------------------------------------------------------------------------------------------------------------------------------------
* 构造方法
** 特点:
* 方法名称和类名系统
* 没有返回值类型,连void也没有
* 没有具体的返回值
** 作用: 对数据进行初始化的
** 注意事项:
* 如果我们没有给出构造方法,那么系统会提供一个无参的构造方法
* 如果我们给出了构造方法,那么系统就不会系统无参的构造方法
* 对象的创建步骤
Student s = new Student() ;
1. 把Student.class加载到方法区
2. 在栈内存中为s开辟空间
3. 在堆内存中为new Student() 开辟空间
4. 给对象的成员变量进行默认初始化
5. 给对象的成员变量进行显式初始化
6. 调用构造方法对成员变量进行初始化
7. 把堆内存中的地址值赋值给栈内存中的引用变量s
* static 关键字
** 意思: 静态的
** 特点:
1. 被static修饰的成员,被该类的所有的对象所共享
2. 随着类的加载而加载
3. 优先于对象存在
4. 可以通过类名访问,本身也可以通过对象名访问 ,建议使用类名
** 注意事项:
1. 静态方法中不能存在this关键字
2. 静态只能访问静态 , 而非静态可以访问静态也可以访问非静态
* API的查看
** 步骤:
1. 双击打开API
2. 点击显示, 找到索引
3. 输入要查找的类名 , 敲击Enter两次
4. 看该类所属的包, java.lang包下的类,在使用的时候不需要导包 ,其他的都需要导包
5. 看该类的描述
6. 看版本
7. 看构造方法 ; 目的: 看我们如何来创建该类的对象
8. 看方法摘要
* 左边 看返回值类型(目的: 看待会我们调用完方法以后,应该使用什么数据类型进行接收) , 以及是否是静态(目的: 看该方法我们是否可以通过类名直接访问)
* 右边 看参数列表; (目的: 看我们调用该方法的时候需要传递一个什么样数据类型的数据)
class StudentDemo {
public static void main(String[] args) {
// 调用Student类中的createStudent的方法
Student s = new Student() ;
// 创建一个IPhone对象
IPhone p = IPhone.createIPhone() ;
Student haha = s.createStudent(p) ;
// 调用show方法
haha.show() ;
}
}
class IPhone { // 要的都是对象
public static IPhone createIPhone() {
return new IPhone() ;
}
public void usePhone() {
System.out.println("使用苹果手机打电话....") ;
}
}
class Student {
public Student createStudent(IPhone iphone) {
iphone.usePhone() ;
return new Student() ;
}
public void show() {
System.out.println("学生晕倒了.................") ;
}
}
day008 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* 代码块
** 概述: 使用{}括起来的代码
** 分类:
* 局部代码块:
位置: 在方法定义中
作用: 限定变量的生命周期
* 构造代码块
位置: 在类中方法外
特点: 每创建一次对象,就执行一次 ; 优先于构造方法执行
* 静态代码块 (掌握)
位置: 在类中方法外 , 前面需要添加上static
特点: 随着类的加载而执行 , 优先于构造代码块 , 只执行一次
* 同步代码块(多线程)
* 继承
** 格式: class 子类 extends 父类 {}
** 好处:
* 提高了代码的复用性
* 提高了代码的维护性
* 让类和类产生了关系,是多态的前提
** 弊端: 提高了的代码的耦合性 ; 开发的原则是: 高内内聚 , 低耦合
** 特点: 只支持单继承 , 不支持多继承 , 但是支持多层继承
** 注意事项:
* 子类只能继承父类中非私有的成员
* 父类的构造方法,子类不能继承 , 但是可以通过super关键字去访问
* 不能为了某一些功能去使用继承 ; 我们继承体现的是 "is a"的关系
** 继承中成员的访问特点:
* 成员变量: 遵循一个"就近原则"
this 和 super 的区别:
this 代表的是本类对象的一个引用
super 代表的是父类对应的一个引用
this 和 super 去访问成员的时候的格式:
成员变量 this.变量名 ; super.变量名 ;
构造方法 this(...) ; super(...) ;
成员方法 this.方法名(...) ; super.方法名(...) ;
* 构造方法: 子类在初始化的时候,默认需要调用父类无参的构造方法
所有的构造方法的第一条语句默认是 super() ;
Object: 是继承体系中的顶层父类,所有的类都是直接或者间接的继承该类
this(...) 和 super(...) 不能同时存在 , 必须是构造方法的第一条语句
* 成员方法 : 查找顺序为: 先在本类中查找 , 如果没有上父类中查找 , 父类如果没有 ,就报错了 ;
* 方法的重写的注意事项:
** 父类中私有的方法,子类不能重写
** 子类在重写父类的方法的时候,要求访问权限不能低于父类的方法权限,最好一致
** 父类中静态的方法,子类在重写的时候,需要使用静态
* 方法重写和方法重载的区别
** 方法重写,发生在子父类的继承中, 子类中出现了和父了一模一样的方法(方法名称 , 参数列表 , 返回值)
** 方法重载,发生在同一个类中 , 允许同时存在两个以后的同名方法 , 只要参数列表不同 , 和返回值没有关系
* final 关键字
final: 是一个修饰符 , 意思: 最终的
final 可以修饰类 , 方法 , 变量
被final 修饰的类 , 不能被继承
被final修饰的方法 , 不能被重写
被final修饰的变量,其实是一个常量,只能被赋值一次
day09 ----------------------------------------------------------------------------------------------------------------------
* 多态
** 概述: 就是同一个事物在不同时刻表现出来的不同状态
** 前提:
* 需要存在继承的关系
* 需要存在方法重写
* 需要存在父类的引用指向子类对象 父 f = new 子() ;
** 多态的形式访问类中的成员
* 成员变量 编译看左边 , 运行看左边
* 构造方法 子类在初始化的时候,都要默认调用父类无参的构造方法,对父类的数据进行初始化
* 成员方法
** 非静态成员方法 编译看左边 , 运行看右边
** 静态成员方法 编译看左边 , 运行看左边
** 多态的好处和弊端
* 好处:
** 提高了代码的复用性
** 提高了代码的维护性
** 提高了代码的扩展性
* 弊端:
** 不能访问子类特有的功能
** 向下转型: 格式: 子类 对象名 = (子类)父类的引用 ;
** 向上转型: 多态就是向上转型的一种体现形式
* 抽象类
** 定义抽象类的格式: abstract class 类名 {}
** 定义抽象方法的格式: 修饰符 abstract 返回值类型 方法名称(参数列表) ;
** 特点:
1. 抽象类不能直接实例化,但是可以通过多态的形式对其进行间接实例化
2. 抽象类中不一定要存在抽象方法,但是如果一个类中存在了抽象方法,那么这个类我们就需要定义成抽象类
3. 子类的问题:
* 可以是抽象类
* 可以是非抽象类 , 但是这个类必须要重写抽象类中所有的抽象方法
** 成员特点
* 成员变量 可以是变量,也可以是常量
* 构造方法 有 , 作用: 用于子类在访问父类数据的时候对父类数据进行初始化
* 成员方法 可以是抽象方法,也可以是非抽象方法
* 接口
** 定义接口的格式: interface 接口名 {}
** 特点:
1. 接口不能直接实例化,但是可以通过多态的形式对其进行间接实例化
2. 子类的问题:
* 可以是抽象类
* 可以是非抽象类 , 但是这个类必须要重写接口中所有的抽象方法
** 成员特点
* 成员变量 只能是常量; 因为存在默认的修饰符: public static final
* 构造方法 没有
* 成员方法 只能是抽象方法, 因为存在默认的修饰符: public abstract
** 类与类 , 类与接口 , 接口和接口之间的关系
* 类与类继承(extends)的关系,只能是单继承 , 但是可以是多层继承
* 类与接口是实现(implements)的关系 , 可以是单实现, 也可以是多实现; 并且一个类在继承一个类的同时去实现多个接口
* 接口和接口是继承(extends)的关系 , 可以是单继承,也可以是多继承
** 抽象类和接口的区别
* 成员的区别
* 关系的区别
* 设计理念的区别
抽象类可以被继承 ,体现的是一种"is a"的关系 , 抽象类中定义的都是该继承体系中共性的内容
接口需要被实现 , 体现的是一种"like a"的关系 , 接口中定义的都是该继承体系中扩展性的内容
day10 ----------------------------------------------------------------------------------------------------------------------
* 包(了解)
* 四种权限修饰符
本类 同一个包下(子类和无关类) 不同包下的子类 不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
* 内部类
** 概述: 就是把一个类定义在另一个类中,那么这个类我们就将其称之为内部类
** 按照位置进行分类:
* 成员内部类 就是把这个类定义在了成员位置(类中方法外的位置)
** private: 提高数据的安全性
** static : 访问其他的类访问
** 非静态的成员内部类被其他类创建对象的格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象 ;
** 静态的成员内部类被其他类创建对象的格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
* 局部内部类 就是把这个类定义在局部位置(方法定义中的位置)
** 特点: 局部内部类在访问局部变量的时候,要求这个局部变量要被final修饰
** 为什么? 请看图片---- 局部内部类的特点.png
** 内部类的特点
* 内部类可以直接访问外部类的成员,包含私有的
* 外部类要访问内部类的成员,需要创建对象
** 匿名内部类
* 它是局部内部类的简化格式
* 前提: 需要存在一个类或者接口 ; 这个类可以是抽象类, 也可以是非抽象类 ;
* 格式:
new 类名/接口名() {
方法重写 ;
} ;
* 本质: 就是一个继承某一个类或者实现某一个接口的子类对象
|
|
收藏
淘帖
踩
