目录
面对象基础
对象
类
类与对象的关系
类的编写
类的组成
this
对象的创建过程
匿名对象
面向对象三大特征
封装
继承
多态
面对象基础
对象
描述一个真实存在的事物
类
多个对象抽取其共同点形成的一个概念
创建对象：
语法：
类名 对象名=new 类名(实参列表);
类与对象的关系
生活中：先有对象后有类
Java中：先有类后有对象，
一个类可以有多个对象，
多个对象可以同属一个类
类的编写
语法:
访问权限修饰符 class 类名{
}
访问权限修饰符:public
类的组成
属性:
别名:成员变量;
本质:类内方法外定义的变量
定义格式:
访问权限修饰符 数据类型 变量名;
构造函数:
别名:构造方法;
定义格式:
访问权限修饰符 类名(形参列表){
方法体;
}
方法:
别名:函数
定义格式:
访问权限修饰符 修饰符 返回值类型 方法名(形参列表){
方法体;
return xxx;
}
this
概念:
谁调用this所在的方法,this就是谁
使用:
一般在成员变量和局部变量重名时,用于区分成员变量和局部变量,用this.变量名代表成员
变量;
对象的创建过程
创建对象语法:
类名 对象名=new 类名(实参列表);
创建过程:
1.在堆内存中开辟一片运行内存,
2.给对象属性赋初值
3.执行构造函数中的代码
4.将栈中的引用指向堆中开辟的地址
匿名对象
概念:没有对象名的对象
语法:
new 类名(实参列表)
缺点:
只能使用一次
导致代码结构混乱
面向对象三大特征
封装
思想：包装
优点：
1.美化
2.降低耦合度
3.保护内部
4.方便使用
java代码中的封装：
变量：封装一个可以改变的数据
数组：封装一组数据
方法：封装一段代码
类：封装多个属性和方法
Java文件：封装一个或多个类
包：封装多个文件夹
项目：封装多个包
包：
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package填写包名
注意:
包名使用全小写,不要用数组开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
访问权限修饰符：
意思：限制属性，方法，构造函数，类等的使用范围
分类：
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中活继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结：
一般情况下：
属性用private修饰，方法与类用public修饰
属性用private修饰后需提供get与set方法
继承
概念：
生活中的继承：晚辈获取长辈留下的财产与精神
Java中继承：
多个类（B1，B2）抽取其共同特点形成一个类（A）
判断类A是否与类B有继承关系
如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法
类A：称为类B的父类
类B：称为类A的子类
优点：
1.减少代码
2.使代码结构清晰
3.减低代码冗余度
super的使用：
1.调用父类的构造函数：
super（实参列表）；
注意：
1.要在子类构函数的第一行；
2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，
2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性
3.子类与父类方法:
要求:
在继承关系中
方法名相同
形参列表相同
返回值相同
子类访问权限修饰符比父类只可增大,不能减小
方法体不同
这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名
总结:
子类将拥有父类的所有属性和方法,构造方法除外.
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造方法
方法
}
注意:
一个子类只能有一个直接父类(继承)
Java最终基类是object,如果一个类没有写继承,默认继承object
多态
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
描述一个真实存在的事物
类
多个对象抽取其共同点形成的一个概念
创建对象：
语法：
类名 对象名=new 类名(实参列表);
类与对象的关系
生活中：先有对象后有类
Java中：先有类后有对象，
一个类可以有多个对象，
多个对象可以同属一个类
类的编写
语法:
访问权限修饰符 class 类名{
}
访问权限修饰符:public
类的组成
属性:
别名:成员变量;
本质:类内方法外定义的变量
定义格式:
访问权限修饰符 数据类型 变量名;
构造函数:
别名:构造方法;
定义格式:
访问权限修饰符 类名(形参列表){
方法体;
}
方法:
别名:函数
定义格式:
访问权限修饰符 修饰符 返回值类型 方法名(形参列表){
方法体;
return xxx;
}
this
概念:
谁调用this所在的方法,this就是谁
使用:
一般在成员变量和局部变量重名时,用于区分成员变量和局部变量,用this.变量名代表成员
变量;
对象的创建过程
创建对象语法:
类名 对象名=new 类名(实参列表);
创建过程:
1.在堆内存中开辟一片运行内存,
2.给对象属性赋初值
3.执行构造函数中的代码
4.将栈中的引用指向堆中开辟的地址
匿名对象
概念:没有对象名的对象
语法:
new 类名(实参列表)
缺点:
只能使用一次
导致代码结构混乱
面向对象三大特征
封装
思想：包装
优点：
1.美化
2.降低耦合度
3.保护内部
4.方便使用
java代码中的封装：
变量：封装一个可以改变的数据
数组：封装一组数据
方法：封装一段代码
类：封装多个属性和方法
Java文件：封装一个或多个类
包：封装多个文件夹
项目：封装多个包
包：
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package填写包名
注意:
包名使用全小写,不要用数组开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
访问权限修饰符：
意思：限制属性，方法，构造函数，类等的使用范围
分类：
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中活继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结：
一般情况下：
属性用private修饰，方法与类用public修饰
属性用private修饰后需提供get与set方法
继承
概念：
生活中的继承：晚辈获取长辈留下的财产与精神
Java中继承：
多个类（B1，B2）抽取其共同特点形成一个类（A）
判断类A是否与类B有继承关系
如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法
类A：称为类B的父类
类B：称为类A的子类
优点：
1.减少代码
2.使代码结构清晰
3.减低代码冗余度
super的使用：
1.调用父类的构造函数：
super（实参列表）；
注意：
1.要在子类构函数的第一行；
2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，
2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性
3.子类与父类方法:
要求:
在继承关系中
方法名相同
形参列表相同
返回值相同
子类访问权限修饰符比父类只可增大,不能减小
方法体不同
这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名
总结:
子类将拥有父类的所有属性和方法,构造方法除外.
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造方法
方法
}
注意:
一个子类只能有一个直接父类(继承)
Java最终基类是object,如果一个类没有写继承,默认继承object
多态
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
多个对象抽取其共同点形成的一个概念
创建对象：
语法：
类名 对象名=new 类名(实参列表);
生活中：先有对象后有类
Java中：先有类后有对象，
一个类可以有多个对象，
多个对象可以同属一个类
类的编写
语法:
访问权限修饰符 class 类名{
}
访问权限修饰符:public
类的组成
属性:
别名:成员变量;
本质:类内方法外定义的变量
定义格式:
访问权限修饰符 数据类型 变量名;
构造函数:
别名:构造方法;
定义格式:
访问权限修饰符 类名(形参列表){
方法体;
}
方法:
别名:函数
定义格式:
访问权限修饰符 修饰符 返回值类型 方法名(形参列表){
方法体;
return xxx;
}
this
概念:
谁调用this所在的方法,this就是谁
使用:
一般在成员变量和局部变量重名时,用于区分成员变量和局部变量,用this.变量名代表成员
变量;
对象的创建过程
创建对象语法:
类名 对象名=new 类名(实参列表);
创建过程:
1.在堆内存中开辟一片运行内存,
2.给对象属性赋初值
3.执行构造函数中的代码
4.将栈中的引用指向堆中开辟的地址
匿名对象
概念:没有对象名的对象
语法:
new 类名(实参列表)
缺点:
只能使用一次
导致代码结构混乱
面向对象三大特征
封装
思想：包装
优点：
1.美化
2.降低耦合度
3.保护内部
4.方便使用
java代码中的封装：
变量：封装一个可以改变的数据
数组：封装一组数据
方法：封装一段代码
类：封装多个属性和方法
Java文件：封装一个或多个类
包：封装多个文件夹
项目：封装多个包
包：
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package填写包名
注意:
包名使用全小写,不要用数组开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
访问权限修饰符：
意思：限制属性，方法，构造函数，类等的使用范围
分类：
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中活继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结：
一般情况下：
属性用private修饰，方法与类用public修饰
属性用private修饰后需提供get与set方法
继承
概念：
生活中的继承：晚辈获取长辈留下的财产与精神
Java中继承：
多个类（B1，B2）抽取其共同特点形成一个类（A）
判断类A是否与类B有继承关系
如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法
类A：称为类B的父类
类B：称为类A的子类
优点：
1.减少代码
2.使代码结构清晰
3.减低代码冗余度
super的使用：
1.调用父类的构造函数：
super（实参列表）；
注意：
1.要在子类构函数的第一行；
2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，
2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性
3.子类与父类方法:
要求:
在继承关系中
方法名相同
形参列表相同
返回值相同
子类访问权限修饰符比父类只可增大,不能减小
方法体不同
这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名
总结:
子类将拥有父类的所有属性和方法,构造方法除外.
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造方法
方法
}
注意:
一个子类只能有一个直接父类(继承)
Java最终基类是object,如果一个类没有写继承,默认继承object
多态
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
语法:
访问权限修饰符 class 类名{
}
访问权限修饰符:public
属性:
别名:成员变量;
本质:类内方法外定义的变量
定义格式:
访问权限修饰符 数据类型 变量名;
构造函数:
别名:构造方法;
定义格式:
访问权限修饰符 类名(形参列表){
方法体;
}
方法:
别名:函数
定义格式:
访问权限修饰符 修饰符 返回值类型 方法名(形参列表){
方法体;
return xxx;
}
this
概念:
谁调用this所在的方法,this就是谁
使用:
一般在成员变量和局部变量重名时,用于区分成员变量和局部变量,用this.变量名代表成员
变量;
对象的创建过程
创建对象语法:
类名 对象名=new 类名(实参列表);
创建过程:
1.在堆内存中开辟一片运行内存,
2.给对象属性赋初值
3.执行构造函数中的代码
4.将栈中的引用指向堆中开辟的地址
匿名对象
概念:没有对象名的对象
语法:
new 类名(实参列表)
缺点:
只能使用一次
导致代码结构混乱
面向对象三大特征
封装
思想：包装
优点：
1.美化
2.降低耦合度
3.保护内部
4.方便使用
java代码中的封装：
变量：封装一个可以改变的数据
数组：封装一组数据
方法：封装一段代码
类：封装多个属性和方法
Java文件：封装一个或多个类
包：封装多个文件夹
项目：封装多个包
包：
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package填写包名
注意:
包名使用全小写,不要用数组开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
访问权限修饰符：
意思：限制属性，方法，构造函数，类等的使用范围
分类：
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中活继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结：
一般情况下：
属性用private修饰，方法与类用public修饰
属性用private修饰后需提供get与set方法
继承
概念：
生活中的继承：晚辈获取长辈留下的财产与精神
Java中继承：
多个类（B1，B2）抽取其共同特点形成一个类（A）
判断类A是否与类B有继承关系
如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法
类A：称为类B的父类
类B：称为类A的子类
优点：
1.减少代码
2.使代码结构清晰
3.减低代码冗余度
super的使用：
1.调用父类的构造函数：
super（实参列表）；
注意：
1.要在子类构函数的第一行；
2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，
2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性
3.子类与父类方法:
要求:
在继承关系中
方法名相同
形参列表相同
返回值相同
子类访问权限修饰符比父类只可增大,不能减小
方法体不同
这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名
总结:
子类将拥有父类的所有属性和方法,构造方法除外.
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造方法
方法
}
注意:
一个子类只能有一个直接父类(继承)
Java最终基类是object,如果一个类没有写继承,默认继承object
多态
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
概念:
谁调用this所在的方法,this就是谁
使用:
一般在成员变量和局部变量重名时,用于区分成员变量和局部变量,用this.变量名代表成员
变量;
创建对象语法:
类名 对象名=new 类名(实参列表);
创建过程:
1.在堆内存中开辟一片运行内存,
2.给对象属性赋初值
3.执行构造函数中的代码
4.将栈中的引用指向堆中开辟的地址
匿名对象
概念:没有对象名的对象
语法:
new 类名(实参列表)
缺点:
只能使用一次
导致代码结构混乱
面向对象三大特征
封装
思想：包装
优点：
1.美化
2.降低耦合度
3.保护内部
4.方便使用
java代码中的封装：
变量：封装一个可以改变的数据
数组：封装一组数据
方法：封装一段代码
类：封装多个属性和方法
Java文件：封装一个或多个类
包：封装多个文件夹
项目：封装多个包
包：
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package填写包名
注意:
包名使用全小写,不要用数组开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
访问权限修饰符：
意思：限制属性，方法，构造函数，类等的使用范围
分类：
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中活继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结：
一般情况下：
属性用private修饰，方法与类用public修饰
属性用private修饰后需提供get与set方法
继承
概念：
生活中的继承：晚辈获取长辈留下的财产与精神
Java中继承：
多个类（B1，B2）抽取其共同特点形成一个类（A）
判断类A是否与类B有继承关系
如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法
类A：称为类B的父类
类B：称为类A的子类
优点：
1.减少代码
2.使代码结构清晰
3.减低代码冗余度
super的使用：
1.调用父类的构造函数：
super（实参列表）；
注意：
1.要在子类构函数的第一行；
2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，
2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性
3.子类与父类方法:
要求:
在继承关系中
方法名相同
形参列表相同
返回值相同
子类访问权限修饰符比父类只可增大,不能减小
方法体不同
这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名
总结:
子类将拥有父类的所有属性和方法,构造方法除外.
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造方法
方法
}
注意:
一个子类只能有一个直接父类(继承)
Java最终基类是object,如果一个类没有写继承,默认继承object
多态
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
概念:没有对象名的对象
语法:
new 类名(实参列表)
缺点:
只能使用一次
导致代码结构混乱
封装
思想：包装
优点：
1.美化
2.降低耦合度
3.保护内部
4.方便使用
java代码中的封装：
变量：封装一个可以改变的数据
数组：封装一组数据
方法：封装一段代码
类：封装多个属性和方法
Java文件：封装一个或多个类
包：封装多个文件夹
项目：封装多个包
包：
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package填写包名
注意:
包名使用全小写,不要用数组开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
访问权限修饰符：
意思：限制属性，方法，构造函数，类等的使用范围
分类：
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中活继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结：
一般情况下：
属性用private修饰，方法与类用public修饰
属性用private修饰后需提供get与set方法
继承
概念：
生活中的继承：晚辈获取长辈留下的财产与精神
Java中继承：
多个类（B1，B2）抽取其共同特点形成一个类（A）
判断类A是否与类B有继承关系
如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法
类A：称为类B的父类
类B：称为类A的子类
优点：
1.减少代码
2.使代码结构清晰
3.减低代码冗余度
super的使用：
1.调用父类的构造函数：
super（实参列表）；
注意：
1.要在子类构函数的第一行；
2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，
2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性
3.子类与父类方法:
要求:
在继承关系中
方法名相同
形参列表相同
返回值相同
子类访问权限修饰符比父类只可增大,不能减小
方法体不同
这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名
总结:
子类将拥有父类的所有属性和方法,构造方法除外.
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造方法
方法
}
注意:
一个子类只能有一个直接父类(继承)
Java最终基类是object,如果一个类没有写继承,默认继承object
多态
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
思想：包装
优点：
1.美化
2.降低耦合度
3.保护内部
4.方便使用
java代码中的封装：
变量：封装一个可以改变的数据
数组：封装一组数据
方法：封装一段代码
类：封装多个属性和方法
Java文件：封装一个或多个类
包：封装多个文件夹
项目：封装多个包
包：
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package填写包名
注意:
包名使用全小写,不要用数组开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
访问权限修饰符：
意思：限制属性，方法，构造函数，类等的使用范围
分类：
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中活继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结：
一般情况下：
属性用private修饰，方法与类用public修饰
属性用private修饰后需提供get与set方法
概念：
生活中的继承：晚辈获取长辈留下的财产与精神
Java中继承：
多个类（B1，B2）抽取其共同特点形成一个类（A）
判断类A是否与类B有继承关系
如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法
类A：称为类B的父类
类B：称为类A的子类
优点：
1.减少代码
2.使代码结构清晰
3.减低代码冗余度
super的使用：
1.调用父类的构造函数：
super（实参列表）；
注意：
1.要在子类构函数的第一行；
2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，
2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性
3.子类与父类方法:
要求:
在继承关系中
方法名相同
形参列表相同
返回值相同
子类访问权限修饰符比父类只可增大,不能减小
方法体不同
这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名
总结:
子类将拥有父类的所有属性和方法,构造方法除外.
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造方法
方法
}
注意:
一个子类只能有一个直接父类(继承)
Java最终基类是object,如果一个类没有写继承,默认继承object
多态
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
概念:
一个事物的多种形态
代码中的多态:
事
方法重写与重载
物(对象)
如类A继承类B
类A:子类
类B:父类
类名 A 对象名A = new 类名A();
类名 B 对象B = 对象A ; //子类转父类,可以直接转换(小类型转大类型)
类名 A 对象A2 = (类名A)对象B; //父类对象转换子类对象,需强制转换,有风险
重写:
要求:
1,继承关系中
2,访问权限修饰符:子类只能比父类大或不变
3,返回值类型:相同
4,方法名:相同
5,形参列表:相同
6,方法体:不同
重载:
要求:
1,同一个类中
2,访问权限修饰符:不管
3,返回值类型:不管
4,方法名:相同
5,形参列表:不相同
6,方法体:不同
