如果子类的一个方法名字和父类的一个方法名字是一样的，那么会出现什么叫结果？

重写(Override)：子类扩展了父类，子类是一个特殊的父类。大部分时候，子类总是以父类为基础，额外增加新的Field和方法。但有一种情况例外：子类需要重写父类的方法。例如鸟类都包含了飞翔方法，其中鸵鸟是一种特殊的鸟类，因此鸵鸟应该是鸟的子类，因此它也将从鸟类获得飞翔方法，但这个飞翔方法明显不适合鸵鸟，为此，鸵鸟需要重写鸟类的方法。

//鸟的父类
public class Bird{
    public void fly(){
        sout("我在天空中自由的飞翔")；
    }
}

//鸵鸟类
public class Ostrich extends Bird{
    public void fly(){
        sout("我只能在地上奔跑")；
    }
}

注意：覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法，不能一个是类方法，一个是实例方法。

super限定符：super是Java的一个关键字，super用于限定该对象调用它从父类继承得到的Field或方法(这也是为什么super不能出现在static修饰的方法里面一样)。如果需要在子类方法中调用父类被覆盖的实例方法，则可使用super限定来调用父类被覆盖的实例方法

public class Ostich entends Bird{
    public void fly(){
        super.fly();//调用父类的fly方法
    }
}

（二）多态（Polymorphism）

多态：多态是同一个行为具有多个不同表现形式或形态的能力。

Java引用变量有两个类型： 一个是编译时的类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行的时候由实际赋值给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态（Polymorphism)

class Shape {
    void draw() {}
}
 
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

多态实现的方式：(课上会具体讲述)

1. 重写Overriding ： extends subclass_name （和重载Overloading的区别）
2. 实现接口 : implements interface_name
3. 继承抽象类和实现抽象方法 : extends abstract_class_name

1.重写遵循以下规则：

• 参数列表必须完全和被重写方法的参数列表一致。
• 返回类型必须完全和被重写方法的返回类型一致。
• 访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）。
• 重写的方法一定不能抛出新的检查异常或者比被重写方法声明更加宽泛的检测型异常。

2.重载的注意事项：

• 在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）。
• 各个重载方法的参数列表必须不同。
• 各个重载方法的返回值类型可以相同也可以不同，但是仅仅返回值类型不同的不是重载。
• 不能通过仅仅通过访问权限、返回类型、抛出的异常的不同而进行重载

（三）封装

封装：是面向对象方法中的重要原则，解释拔对象的属性和操作结合为一个独立的整体，并尽可能的隐藏其中的内部实现细节。

优点：

1. 减少耦合
2. 类的内部结构可以自由修改
3. 隐藏信息，实现细节

一个良好的类定义：

public class Person{
   //一些基本属性
    private String name;
    private int age;
    private String sex;

    //一些setter和getter
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    private int getAge(){
        return age;
    }
    private void setAge(int age){
        this.age = age;
    }
    public void setSex(String sex){
        this.sex = sex;
    }
}

我们为什么要定义以上的setter和getter呢？这不是麻烦了吗？我们来分析一下：

如果没有getter和setter的话，代码是这样的

public class Person{
   //一些基本属性
    private String name;
    private int age;
    private String sex;
}

我们使用的时候是这样的：

Person person = new Person();  
person.age = 25;  
person.name = "张三";  
person.sex = "男";

如果某一天。我们想修改 sex属性为 int类型，那么我们需要修改很多代码，（改到人生崩溃

但是我们只要定义一个setter就可以实现了：

public class Person{
   //一些基本属性
    private String name;
    private int age;
    private String sex;
    public void setSex(int m){
        if(m == 0){
            this.sex = "男"
        }else{
            this.sex = "女"；
        }
    }
}

所以我们可以通过封装这个类 来实现具体的内部代码, 只要给外部提供一个接口就可以了.

同时我们也可以增强安全性

如果我们不想让其他类直接访问我们的成员属性，那我们直接在 其getter上增加修饰符private就ok了，这时候除了这个类的内部成员其他的类不可以访问这个属性

public class Person{
   //一些基本属性
    private String name;
    private int age;
    private String sex;
    //应为是private所以外部类无法调用，这也意味着除了这个类，其他的类没有了访问sex这个属性的方法。
    private String getSex(){
        return this.sex;
    }
}

常用类解析

1.String

String类详细教程

构造方法：

String str = "Runoob";
String str2=new String("Runoob");

二者的区别：

String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

int length();		// 返回字符串的长度
String1.concat(String2)		// 将字符串2接在字符串1的前面
char charAt(int index)  	//取得索引处的char值
int compareTo(String anotherString) //比较两个字符串的大小
char[] toCharArray()			  //将字符串转为字符数组
boolean isEmpty()				//判断是否为空

2. 日期时间

Date类详细教程

Java.util包中提供了Date类封装当前的日期和时间

构造函数：

Date() //默认构造函数，使用当前时间来初始化对象
Date(long millisec) //接收一个参数，该参数是1970年1月1日开始计时的

3.Scanner

4.StringBuilder类

5. Math类

…

---