方法、封装、继承、多态

一. 方法

1.1 方法的定义和调用：

1).方法内部实现功能时，是否需要外部数据(来决定是否需要参数)；
2).方法内部实现功能后，是否有运行结果(来决定是否需要返回值);

public static void main(String[] args) {
        int sum = getSum(7, 6);//7和6叫“实参”
         System.out.println(sum);
    }
    public static int getSum(int a,int b){//a和b叫"形参"
        return  a+b;
    }

1).形参：在“定义”方法时的参数叫：形参(形式参数)。格式：数据类型 变量名
2).实参：在“调用”方法时传递的真实的参数数据较：实参(实际的参数)。格式：方法名(实参);

1.2方法的重载

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返 回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

public static void main(String[] args) {
        sum(10,20);
        sum(10,20,30);
        sum(3.14,5.6);
    }
    public static void sum(int a ,int b){
        System.out.println(a + b);
    }
    public static void sum(int a ,int b,int c){
        System.out.println(a + b + c);
    }
    public static void sum(double a ,double b){
        System.out.println(a + b);
    }

二. 封装

1. 使用 private 关键字来修饰成员变量。（只在本类中才能访问）
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。
   private 数据类型 变量名 ；

2.1. -----this

使用 private 修饰成员变量:

public class Student { 
	private String name; 
	private int age; 
}

提供 getXxx 方法 / setXxx 方法，可以访问成员变量

public void setName(String name) {
	 //name = name;  错误，这里访问的name都是"参数的name"。不是成员的name属性。
	 this.name = name;//this.name表示成员的name属性；name表示参数的name
  }
  public String getName() { 
 	 return name;//这里可以不用this，因为也没有"同名的局部变量”，所以可以直接找到成员的name。也可以用 
  }
  public void setAge(int age) { 
	  //age = age; 错误 
	  this.age = age; 
  }
  public int getAge() { 
  	return age; 
  }

2.2. -----构造方法

修饰符 构造方法名(参数列表){ // 方法体 }

public class Student { 
	private String name; 
	private int age; 
	// 无参数构造方法‐‐用于创建对象时无参构造：
	Student stu = new Student(); 
	public Student() {} 
	
	// 有参数构造方法‐‐用于创建对象时带参构造：
	Student stu = new Student("高圆圆",18); 
	public Student(String name,int age) { 
		this.name = name;
		 this.age = age;
	  }
  }

1. 如果不提供构造方法，系统会给出无参数构造方法。
2. 如果提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

三. 继承

3.1 继承

就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。
extends 关键字

父类 员工类Employee

class Employee { 
		String name; // 定义name属性 
		// 定义员工的工作方法 
		public void work() { 
			System.out.println("尽心尽力地工作"); }
		 }
}

定义老师类Teacher 继承 员工类Employee

class Teacher extends Employee { 
		public void printName() { 
			System.out.println("name=" + name); 
		} 
 }

定义测试类

public class ExtendDemo01 { 
	 public static void main(String[] args) { 
		 Teacher t = new Teacher(); 
		 t.name = "小明"; // 调用该员工的printName()方法
  	     t.printName(); // name = 小明 
		// 调用Teacher类继承来的work()方法 
		 t.work(); // 尽心尽力地工作 
		 } 
  }

1. Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
 class C extends A{} //ok 
 class C extends A，B... //error

2. Java支持多层继承(继承体系)。

class A{} 
class B extends A{} 
class C extends B{}

3. 子类和父类是一种相对的概念。

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰 父类成员变量
super.父类成员变量名

3.1.方法重写

如果子类父类中出现重名的成员方法，叫做方法重写 (Override)。
方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同，会出现覆盖效果也称为重写或者复写。

父类：

class Phone {
	 public void sendMessage(){ 
	 		System.out.println("发短信");
	  }
	  public void call(){ 
	  		System.out.println("打电话");
	   }
	   public void showNum(){ 
	  	 	System.out.println("来电显示号码");
	    }
  }

子类：

//智能手机类 
class NewPhone extends Phone { 
	public void showNum(){ 
			super.showNum(); 
			System.out.println("显示来电姓名"); 
			System.out.println("显示头像"); 
		} 
}

测试类

public class ExtendsDemo06 { 
		public static void main(String[] args) { 
			NewPhone np = new NewPhone()； 
			// 调用父类继承而来的方法 
			np.call(); 
			// 调用子类重写的方法 
			np.showNum(); 
		}
 }

1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

四.多态

4.1 多态的体现

多态： 是指同一行为，具有多个不同表现形式。
父类类型 变量名 = new 子类对象； 变量名.方法名();
父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

父类

public class Animal {
        public void eat(){
            System.out.println("动物都要吃饭")
        };
    }

子类

 class Cat extends Animal { 
        //重写父类的方法 
        public void eat() {
            System.out.println("吃鱼");
        }
    }
    
    class Dog extends Animal { 
        //重写父类的方法
        public void eat() { 
            System.out.println("吃骨头"); 
        } 
    }

测试类

   public class Test { 
        public static void main(String[] args) { 
            Animal a1 = new Cat(); 
             a1.eat(); 
            Animal a2 = new Dog();
            a2.eat(); 
        } 
    }

4.2 引用类型转换

4.2.1.向上转型

多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。 
当父类引用指向一个子类对象时，便是向上转型。

父类类型 变量名 = new 子类类型(); 如：Animal a = new Cat();

4.2.2 向下转型

父类类型向子类类型向下转换的过程，这个过程是强制的。 
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

子类类型 变量名 = (子类类型) 父类变量名; 如:Cat c =(Cat) a;

eg：

public class Test {
        public static void main(String[] args) {
            // 向上转型
            Animal a = new Cat();
            a.eat(); // 调用的是 Cat 的 eat
            // 判断a是否是Cat类型
            if (a instanceof Cat){
                Cat c = (Cat)a; //向下转型
                c.catchMouse(); // 调用的是 Cat 的 catchMouse
                } else if (a instanceof Dog){
                //判断a是否是Dog类型
              Dog d = (Dog)a; //向下转型
              d.watchHouse(); // 调用的是 Dog 的 watchHouse
            } 
        }
    }