Java面向对象
一，方法
1，方法的概述
方法：拥有功能性代码的代码块，一个功能就是一个方法
好处：方便使用，好维护
2，方法的定义
修饰符 返回值类型 方法名(参数){
方法体
return 结果
}
1.修饰符:public static
2.返回值类型:该方法返回的结果的数据类型,要和方法体中return后面的那个数据类型一致
如果方法没有返回值,请用void代表
3.方法名:遵循小驼峰式,见名知意
4.参数:进入到方法内部参与运行的数据
数据类型 变量名,数据类型 变量名
5.方法体:实现该方法的具体代码,在方法体中要操作传进来的参数
6.return 结果:代表返回值,操作参数之后得出的最终结果
方法的类型：
- 无参无返回值的方法
public static void method(){
方法体
}
调用方法：方法名.()
- 有参无返回值的方法
public static void method(int a){
方法体
}
- 无参有返回值的方法
public static int method(){
方法体
return 结果；
}
- 有参有返回值的方法
public static int method(){
方法体
return 结果
}
3，形参和实参的区别
- 形式参数:
在定义方法的时候,定义的没有具体值的参数 - 实际参数:
在调用的时候为参数赋的值
4，注意事项
- 方法不调用不执行
- 方法之前不能互相嵌套,方法和方法之间是平级关系
- 方法的执行顺序只和调用顺序有关系
- void和[return 结果]不能共存,但是void能和return共存
void:代表没有返回值
return 结果:先将结果返回给调用处,然后结束方法
return:仅仅代表结束方法 - 一个方法中,不能连续写多个return
- 调用方法的时候,要看看下面有没有这个方法(方法名,参数个数,参数类型都要匹配)
二，方法的重载
1，概念
1.什么是重载方法:方法名相同,参数列表不同
2.什么叫参数列表不同:
参数个数不同
参数类型不同
参数类型的顺序不同
3.重载方法和什么无关:
a.和参数名无关
b.和返回值无关
4.什么时候可以定义重载方法:当功能一样,但是实现过程细节不同
例子：
public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}
2，成员变量和局部变量的区别
| 成员变量 | 局部变量 | |
|---|---|---|
| 定义位置 | 类中，方法外 | 自己方法内或者参数位置 |
| 作用范围 | 整个类 | 自己的方法内 |
| 初始化 | 自己可以初始化，有默认值 | 无默认值，必须初始化 |
| 内存位置 | 堆中 | 栈中 |
| 生命周期 | 随着对象的创建而创建 ，随着对象的消失而消失 | 随着方法的调用而创建，随着方法调用完毕而消失 |
三，封装
1，封装的介绍及其使用
1.面向对象三大特征: [封装] 继承 多态
2.什么是封装思想:
a.为什么需要封装?封装的作用和含义?
我要用洗衣机,只需要按一下按钮就可以了.有必要了解洗衣机内部构造吗?
b.隐藏对象内部的复杂性,只对外公开简单的接口.便于外界调用,从而提高了系统的可扩展性,可维护性,安全性.通俗的说,把该隐藏的隐藏起来,把该暴露的暴露出来.这就是封装的设计思想
将细节隐藏起来,对外提供一个暴露的接口,供我们使用者使用,我们只需要调用这个接口,接口中的细节(代码)就执行起来了
3.封装思想中最具代表性的关键字:private(权限修饰符)-> 私有权限
a.是一个权限修饰符,代表私有的
b.用法:
修饰一个成员变量
private 数据类型 变量名
修饰一个方法
将public 改成 private
c.特点:
被private修饰的成员别的类不能直接访问,只能自己类中访问
4.将属性私有化了,相当于将细节隐藏了起来,外界不能直接使用,然后我们可以对外提供(暴露)公共的接口:get/set方法
getxxx(): 获取属性值
setxxx(): 为属性赋值
属性被private私有化了,相当于将细节隐藏了,外界无法直接调用了
提供get/set相当于对外提供了公共的接口
setxxx():为属性赋值
getxxx():获取属性值
快速跳到调用的对应位置:按住ctrl不放,点击
注意:属性没有被私有化,也可以提供get/set方法,但是没啥必要,因为没有被私有化的属性,可以直接点出来
2，this关键字
1.如果局部变量和成员变量重名了,遵循"就近原则",先访问局部变量
2.this:概述:代表当前对象
哪个对象调用的this所在的方法,this就代表哪个对象
可以区分重名的局部变量和成员变量
3,构造方法（构造器)
1.作用:new对象
2.特点:
a.方法名和类名一致
b.没有返回值,连void都没有
- 空参构造
1.格式:
类名(){
}
2.作用:
new对象用-> 一new 相当于调用了构造方法,构造方法就自动执行
3.特点:
每个类都默认有一个无参构造方法,但是不同写出来,jvm会自动提供一个
- 有参构造
1.格式:
类名(参数){
方法体
}
2.作用:
a.new对象
b.为属性赋值
3.特点:
jvm不会自动提供有参构造,如果写上了有参构造,jvm将不再提供空参构造
所以建议,空参和有参构造都手动写上
小结：
1.知道private的作用吗?私有成员,外界不能直接点
2.知道get/set方法的作用吗?
set方法:为属性赋值
get方法:获取属性值
3.知道this的作用吗?
表示当前对象->哪个对象调用this所在的方法,this就代表哪个对象
区分重名的成员变量和局部变量->this.后面的就是成员的
4.知道无参构造作用吗?
new对象的-> 不写jvm给一个
5.知道有参构造作用吗?
new 对象,为属性赋值
写了有参构造,空参构造使用不了了
建议,无参,有参都写上
四，继承
1，什么是继承
1. 父类怎么形成的:
定义多个类之后,发现重复的代码太多了,我们没有必要每个类都要写一遍共性的代码
所以,我们定义一个类,将共性的代码抽取出来 放到这个类中,此类就是"父类",其他的类就可以直接继承这个"父类",就可以使用父类中抽取出来的共性的代码了
2.继承:更倾向于是一种代码的设计理念
3.注意:
子类可以继承父类中的私有和非私有成员
但是在子类中不能使用私有成员
父类对象不可调用子类特有方法和属性
4.学习继承不要从"拥有"层面去理解
要从"是否能使用"层面去理解
2，继承的属性
- 关键字:extends
- 格式:
子类 extends 父类 - 父类也叫超类,也叫根类,基类
子类也叫派生类 - 在继承中 通过 get set 对父类中的私有属性赋值和取值
- 成员变量的访问，看等号左边，左边是谁就优先访问谁的，子类没有再去访问父类的
- 成员方法的访问：看new谁，new的是谁就优先访问谁的方法，子类没有，去访问父类的
3，继承中的方法的重写
1.重写的前提:继承关系
2.概述:子类中有一个和父类一毛一样的方法
3.检测此方法是否为重写方法: @Override
注意事项
- 子类方法重写父类方法，必须要保证权限大于等于父类权限。(权限指的是权限修饰符)
public->protected->默认权限->private - 子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。
- 私有方法不能被重写,构造方法不能被重写,静态方法也不能被重写
- 当一个类中的某个功能做升级改造时,我们就可以重写这个方法
4,继承中构造方法的特点
1.注意:初始化子类对象时,先初始化父类对象
2.为什么:
在构造方法的第一行,jvm会自动提供一个super()
super()代表的是父类无参构造
5，super关键字和this关键字的用法
1.super:代表的父类对象,可以调用父类成员
2.使用:
调用父类构造方法:在子类构造中:
super()-> 调用父类无参构造
super(实参)->调用父类有参构造
调用父类成员变量:在子类中
super.成员变量名
调用父类成员方法:在子类中
super.成员方法名()
super.成员方法名(实参)
3.注意:super要是放到构造中使用,必须要在构造第一行,无论调用父类有参还是无参构造
1.概述:this代表的是当前对象
2.使用:调用当前对象中的成员
调用当前对象中的构造方法:在本类的构造中
this()-> 调用当前对象的空参构造
this(实参)->调用当前对象的有参构造
调用当前对象中的成员变量:在本类中写:
this.成员变量
调用当前对象中的成员方法:在本类中写:
this.成员方法()
this.成员方法(实参)
3.注意事项:
如果在构造中使用this,需要在第一行,所以this和super不能在构造中同时写出来
6，继承的特点
1.继承只能单继承,不支持多继承(一个儿子只能有一个亲爹)
public class A extends B,C{} -> 错误
2.继承支持多层继承
public class A extends B{}
public class B extends C{}
3.一个父类可以拥有多个子类
public class B extends A{}
public class C extends A{}
五，多态
1，多态的介绍
1.前提:
a.必须有子父类继承关系,或者接口实现关系
b.多态没有重写的方法,多态没有意义
c.父类引用指向子类对象
好比:double b = 10
b = 100L
b = 2.5F
2.注意:
多态主要是操作重写的方法
多态的前提下,不能调用子类特有方法的
2,多态的基本使用
1.定义一个父类
2.定义一个子类,继承父类
3.重写父类方法
4.创建对象:父类引用指向子类对象
5.调用重写的方法
public class Test01 {
public static void main(String[] args) {
//原始方式
Dog dog = new Dog();
dog.eat();
dog.lookDoor();
Cat cat = new Cat();
cat.eat();
cat.catchMouse();
System.out.println("==================");
//多态形式
Animal animal = new Dog();
animal.eat();
//animal.lookDoor();多态情况下,不能直接调用子类特有方法
}
}
class Animal {
public void eat(){
System.out.println("动物都要吃饭");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗啃骨头");
}
//特有方法
public void lookDoor(){
System.out.println("狗会看门");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
//特有方法
public void catchMouse(){
System.out.println("猫会抓老鼠");
}
}
3,多态条件下成员的访问特点
成员变量：看等号左边是谁,先调动谁的成员变量
成员方法：看new的是谁,先调用谁中的成员方法
注：父类对象不可直接使用子类特有方法
FU fu =new Zi()
//fu.methodZi();多态情况下,不能直接调用子类特有方法
4,多态的好处
1.原始new对象方式:
好处:既能调用父类的,还能调用自己特有的,还能调用重写的
坏处:扩展性差
2.多态方式
好处:扩展性强
坏处:不能直接调用子类特有方法
参数位置传递父类类型,可以接收任意他的子类对象,接收到哪个子类对象,就调用哪个子类对象重写的方法
5.多态中的转型
向上转型：
父类引用指向子类对象->默认
弊端:不能直接调用子类特有功能
向下转型：
1.向下转型相当于强转
父类 对象名 = new 子类()-> 向上转型 -> double b = 10
子类 对象名 = (子类)父类对象名 -> int i = (int)b;
2.特点:
能调用子类特有功能了
转型会遇到的问题：
1.向下转型容易出现的问题:
ClassCastException-> 类型转换异常-> 转型时等号左右两边类型不一致
2.判断类型关键字: instanceof -> boolean
3.使用语法:
对象名 instanceof 类型 -> 关键字前面的对象是否属于关键字后面的类型
