成员变量和局部变量的对比、方法的重写与方法的重载的对比
成员变量和局部变量的对比
答案一：
1.在位置上：
成员变量 ：类中方法外
局部变量: 方法中.
2.在内存中；
成员变量:堆中对象里
局部变量:栈中方法里
3.生命周期:
成员变量: 随着对象的产生而产生，随着对象的消亡而消亡
局部变量: 随着方法的产生而产生,随着方法的消亡而消亡
答案二：
1、从语法形式上，看成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public,private,static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；成员变量和局部变量都能被final所修饰；
2、从变量在内存中的存储方式来看，成员变量是对象的一部分，而对象存在于堆内存，局部变量存在于栈内存
3、从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
4、成员变量如果没有被赋初值，则会自动以类型的默认值而赋值（一种情况例外被final修饰但没有被static修饰的成员变量必须显示地赋值）；而局部变量则不会自动赋值。
方法的重载与重写
重载和重写对比
重载
1.⽅法名相同
2.参数列表不同
3.和修饰符返回值类型⽆关
4. 可以发生在本类之间 也可以发生在子父类之间
重写
1.⽅法名相同
2.参数列表相同
3.返回值类型相同
4.访问修饰符权限子类要大于等于父类
5. 只能发生在子父类之间
异同
1、相同点：
方法名都是相同的
2、不同点：
（1）书写位置：
重载：写在同一个类中
重写：写在子父类中、或者是接口和实现类当中
（2）返回值类型：
重载：无关
重写：引用数据类型相容，基本数据类型相同
（3）参数列表：
重载：不同
重写：相同
重载和重写介绍
1、方法的重载(overload)
概念
定义同名的多个⽅法，⽅法的实现不同 参数列表不同 在调⽤的时候系统会根据所传的参数⾃动匹配
所对应的⽅法，⽤来屏蔽参数类型不同，⽅法实现不同的做法叫做⽅法的重载。
特点
1. 方法名相同
2. 参数列表不同（类型 个数 顺序）
3. 和修饰符 返回值类型无关
注意事项
1. 形式参数名不同 不能形成方法的重载,而是两个相同的方法
2. 当实际参数和所有的方法的形式参数不一致, 系统会按照自动类型提升的原则,就近匹配.
3. 当出现方法重载的时候,要避免方法调用不明确的问题.
案例
//案例1: 关于方法重载的特点的
public class Demo4 {
public static void main(String[] args) {
}
}
// 定义一个数学类
class MyMath{
//用于计算 相加
// int + int
public int add(int a,int b){
return a + b;
}
// int add(int a,int b){
// return a + b;
// }
// public void add(int a,int b){
//
// }
// double + double
public void add(double a,double b){
}
// byte + byte
public void add(byte a,byte b){
}
// int + double
public void add(int a,double b){
}
// double + int
public void add(double a,int b){
}
// int + int + int
public void add(int a,int b,int c){
}
}
//案例2: 关于自动匹配合适的方法
package com.ujiuye.day07;
import com.sun.jmx.snmp.internal.SnmpOutgoingRequest;
public class Demo4 {
public static void main(String[] args) {
int a = 10;
int b = 20;
double c= 12.1;
double d = 12.2;
byte e = 10;
byte f = 20;
MyMath m = new MyMath();
//调用方法
m.add(e,f);
}
}
// 定义一个数学类
class MyMath{
//用于计算 相加
// int + int
public int add(int a,int b){
System.out.println("int + int");
return a + b;
}
// double + double
public void add(double a,double b){
System.out.println("double + double");
}
// byte + byte
public void add(byte a,byte b){
System.out.println("byte + byte");
}
// int + double
public void add(int a,double b){
System.out.println("int + double");
}
// double + int
public void add(double a,int b){
System.out.println("double + int");
}
// int + int + int
public void add(int a,int b,int c){
System.out.println("int + int + int");
}
}
//案例3: 关于就近匹配
package com.ujiuye.day07;
import com.sun.jmx.snmp.internal.SnmpOutgoingRequest;
public class Demo4 {
public static void main(String[] args) {
MyMath m = new MyMath();
int a = 20;
int b = 30;
//调用方法
m.add(a,b);
}
}
// 定义一个数学类
class MyMath{
public void add(float a,float b){
System.out.println("float + float");
}
public void add(long a,long b){
System.out.println("long + long");
}
public void add(double a,double b){
System.out.println("double + double");
}
}
//案例4: 关于在方法重载时 避免方法调用不明确
package com.ujiuye.day07;
import com.sun.jmx.snmp.internal.SnmpOutgoingRequest;
public class Demo4 {
public static void main(String[] args) {
MyMath m = new MyMath();
int a = 20;
int b = 30;
//float c = 12.5F;
//调用方法
m.add(a,b);
}
}
// 定义一个数学类
class MyMath{
public void add(float a,int b){
System.out.println("float + int");
}
public void add(int a,float b){
System.out.println("int + float");
}
}
2、方法的重写（override）
概念
概念：当⽗类中的⽅法的实现⽆法满⾜⼦类的需要，那么就需要在⼦类中定义和⽗类⽅法名相同参数列表相
同但是⽅法的实现不同的⽅法，把这种现象叫做⽅法的重写（覆盖）
要求
1.⽅法名相同 参数列表相同 返回值类型相同 ---> 方法的三要素相同
2.访问权限相同或者更宽 (子类中重写的方法的访问修饰符要大于等于父类中的方法)
private ---> 默认不写 ---> protected ---> public
案例:
import sun.applet.Main;
public class Demo9 {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
WenZi wenZi = new WenZi();
wenZi.eat();
}
}
// 定义一个动物类
class Animal{
String name;
int age;
//吃
void eat(){
System.out.println("动物吃");
}
}
class Dog extends Animal{
// 从父类中继承的方法不能满足子类的需要了 就需要提供一个 方法名 形式参数列表 返回值类型都相同的方法 但是方法的实现不同
public void eat(){
System.out.println("狗吃饭");
}
}
class WenZi extends Animal{
public void eat(){
System.out.println("蚊子滋滋滋的吸血");
}
}
特点
当⼦类对象调⽤被重写后的⽅法时，调⽤的是⼦类中覆盖以后的⽅法
重写的注解检查
@override
标注: 注解
作用: 可以检查方法是否是重写
用法: 加在重写的方法上的
//案例:
import sun.applet.Main;
public class Demo9 {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
WenZi wenZi = new WenZi();
wenZi.eat();
}
}
// 定义一个动物类
class Animal{
String name;
int age;
//吃
public void eat(){
System.out.println("动物吃");
}
}
class Dog extends Animal{
// 从父类中继承的方法不能满足子类的需要了 就需要提供一个 方法名 形式参数列表 返回值类型都相同的方法 但是方法的实现不同
@Override
public void eat(){
System.out.println("狗吃饭");
}
//重载的方法
public void eat(String food){
System.out.println("狗吃"+food);
}
}
class WenZi extends Animal{
@Override
public void eat(){
System.out.println("蚊子滋滋滋的吸血");
}
}
注意
1.⽅法的重写前提是存在继承关系，才会有⼦类重写⽗类的⽅法
2.private修饰的⽅法不能被继承，也就谈不上覆盖
案例:
package com.ujiuye.day09;
import sun.applet.Main;
public class Demo9 {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
WenZi wenZi = new WenZi();
wenZi.eat();
}
}
// 定义一个动物类
class Animal{
String name;
int age;
//吃
public void eat(){
System.out.println("动物吃");
}
//私有的方法 ---> 不能够继承给子类
private void m(){
System.out.println("我是一个私有的方法");
}
}
class Dog extends Animal{
// 从父类中继承的方法不能满足子类的需要了 就需要提供一个 方法名 形式参数列表 返回值类型都相同的方法 但是方法的实现不同
@Override
public void eat(){
System.out.println("狗吃饭");
}
//重载的方法
public void eat(String food){
System.out.println("狗吃"+food);
}
// 私有的方法不能形成重写
// @Override
// m方法可以存在 但是不是重写的关系
public void m(){
System.out.println("m");
}
}
class WenZi extends Animal{
@Override
public void eat(){
System.out.println("蚊子滋滋滋的吸血");
}
}
