重写与重载
重载
重载: 同一个类中, 方法名字相同, 参数列表不同 ,这就形成了重载。与修饰符 , 返回值类型无关
功能类似,但有细微差别则需要定义成重载关系
参数不同: 形式参数的类型 , 顺序 , 个数 , 与参数名字无关
特殊情况: 如果必须要自动转型.但是可以出现多个同级别的 转换则编译报错.
级别有差异,则选择转换少的方法
// 传递实际参数, 程序就会自动查找对应的形参列表的方法
public static void main(String[] args) {
sum(4, 5);
}
public static void sum(double a,int b){
System.out.println("两个int相加");
}
public static void sum(int a,int b,int c){
System.out.println("三个int相加");
}
public static void sum(double d , double e){
System.out.println("两个double相加");
}
重写
重写:在继承关系中,子类方法名,参数列表,返回值必须与父类一致,修饰符不能比父类更严格,抛出的异常不能比父类范围广
重写与重载的区别
成员变量、局部变量
成员变量 局部变量 区别:
1. 声明位置:
成员变量: 类以内,方法以外
局部变量: 方法内部
2. 作用域:
成员变量: 在类的内部都能用
局部变量: 方法内部
3. 默认值:
成员变量: 有默认值, 即使没有初始化也可以使用
局部变量: 没有默认值, 在使用之前必须初始化
4. 内存区域:
成员变量: 内存在堆中
局部变量: 栈中
类和对象
对象是类的实例
类是对象的模板(抽象)
构造方法
写构造方法
public 类名(){}
自己没有生命构造方法之前, 也是可以使用的, 系统提供好的隐式的构造方法, 无参数的
当自己声明了构造方法, 系统则不会提供隐式构造方法, 自己声明的构造方法 叫做 显示构造方法
构造方法是写在new 后面的 自动执行的, 不能通过对象名调用, 作用: 创建对象
构造方法与普通方法的区别:
1. 声明格式不同
2. 调用方式不同
3. 作用不同
1> 实例化对象
2> 给属性复制
面向对象
以具体的事物为单位,更加关注的是事物功能 ,而非流程
大象 大象的功能
特征:
长鼻子
大耳朵
体积大
行为:
冻死的
跑
冰箱 冰箱的功能
特征:
宽
高
容积
行为:
开门
关门
制冷
只需要作为指挥者 ,指挥 对象 , 面向对象的思想, 懒人思想
面向对象 底层 还是用面向过程实现的
事物
对象
类
面向对象中: 抽象 封装 继承 多态
定义类 :
抽取多个对象中共同的特征和行为 抽取的过程 --> 抽象
抽取出来的这些特征和行为 组合成了类
学生:
姓名 成员变量 , 全局变量 , 属性
年龄
学号
吃 方法
喝
玩
乐
学习
class Student{
String name;
int age;
int stuId;
public void eat(){
}
public void drink(){
}
public void play(){
}
public void study(){
}
}
根据类型创建对象
学习面向对象以后 定义多个类
通过类 创建多个对象
类名 对象名 = new 类名();
Student stu = new Student();// new
stu.name = "zhangsan";
stu.age = 5;
stu.stuId = 110;
stu.eat();
System.out.println(stu.name+" "+stu.age+ " "+stu.stuId);
Student stu2 = new Student("张三", 17, 119);
System.out.println(stu2);
封装 private
1. 将属性私有化
2. 提供set/get对外访问的公共接口
3. private 私有 修饰符 私有属性只能在本类使用,其他类不能使用
属性的封装: private int age;
作用:提高数据的安全性
类的封装: 将属性和方法放到类中
作用:方便统一进行管理,安全性
方法的封装: 减少冗余代码,提高代码的复用性,便于维护 , 提高阅读性
// 通过set设置值,get得到值
p.setAge(6);
System.out.println(p.getAge());
p.setGender("男");
System.out.println(p.getGender());
继承 extends
一个子类可以至多继承一个父类 单继承
类来说 单继承
接口 --> 可以同时继承多个接口, 多继承
子类是无法继承父类的构造方法的, 子类也无法重写父类的构造方法
一个父类可以有多个子类 层次继承
一个子类可以继承一个父类 父类--》父类 层级继承
混合继承 --》 java 继承了父类 --》实现了接口 --》 继承接口
访问权限修饰符 public private
static 修饰符
final 修饰符
多态
继承
继承:
1. 上一辈的东西是可以直接使用
2. 父类的一些私有的事物是不能继承的
3. 除了继承的以外 , 还可以有自己特有的爱好
作用:
1、 继承可以减少重复代码, 提高代码的复用性
2、 java继承 增量式的开发
父类 子类 是 is a 的关系
猫 is a 动物 is a 生物 is a 物质 ---》 一串继承关系
茉莉花 is a 花
面包 is a 食物
父类Person 类
有一系列的 属性和方法
子类:
学生类
老师类
工人类
医生类。。。。
在测试类创建子类对象 调用其属性和方法
// 父类
public class Father {
String name;
int age;
private String gender;
public void eat(){
System.out.println("吃");
}
private void smoke(){
System.out.println("吸烟");
}
}
// 子类
class Son extends Father{
public void classOver(){
System.out.println("下课");
}
}
// 子类2
public class SecondSon extends Father{
}
// 测试类
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.eat();
//son.smoke();
son.name = "儿子";
son.age = 2;
//son.gender="weizhi";
son.classOver();
SecondSon secondSon = new SecondSon();
secondSon.eat();
secondSon.name = "aa";
}
}
多态
作用:减少重复代码,提高代码复用性、可读性、可维护性,提高可拓展性
多态: 一个事物 具有多种表现形态
狗 狗 动物
桌子 桌子 物品
水杯 水杯 物品
1. 重载 : 同一个类中 方法名相同 参数列表不同 多态的一种表现
2. 重写: 在继承关系中:子类重写父类的方法, 方法名字和参数列表必须和父类的相同 多态的一种表现
多态:
编译时多态: 在编译时期就可以发现的多态 重载
运行时多态: 在运行时期才能发现的多态 重写
运行时多态有一个前提条件 : 在继承关系中
向上向下转型
子类的对象可以直接当作父类的对象使用,称 向上造型(自动)
从父类的对象到子类的对象转换 称 向下造型 (手动)
用instanceof关键字来判断本质是什么
// 匿名对象 没有名字, 只能调用一次属性或方法
new Cat().eat();
new Cat().sleep();
show(new Cat());// 匿名对象的写法
Monkey monkey = new Monkey();
// 向上转型: 父类的对象名指向了子类的实体
// 向上转型的作用: 减少重复代码, 提高代码的复用性, 可维护性, 提高可拓展性
Animal animal = new Monkey();
Animal animal2 = new Cat();
Animal animal3 = new Dog();
// 调用重写方法 只有在运行时知道是哪个类的对象的时候,才能知道 调用的是否是重写以后的方法的
animal.eat();
animal.sleep();
// 向上转型
Person father = new Son();
father.oprea();
// 向下转型: 向上转型以后,对象无法调用子类特有的方法, 为了决绝这个问题, 线下转型
// 向下转型的前提条件是 先向上转型了
Son son = (Son) father;//
son.biaoyanjava();
// 向下转型
Person person = new SecondSon();
person.oprea();
SecondSon secondSon = (SecondSon) person;// 向下转型
secondSon.studyRY();
但凡是向下转型之前 都要进行 判断 才可以避免 ClassCastException 类型转换异常
instanceof
// father 是否是 secondSon类创建出来的 是则为true
if(person instanceof SecondSon){
//ClassCastException 类型转换异常
SecondSon secondSon2 = (SecondSon) person;
secondSon2.studyRY();
}else{
System.out.println("不对哈");
}