权限修饰符

1.权限从大到小排序：public > protected > default > private

2.权限修饰符可以使用在 方法/属性/类 前

权限修饰符	同一个类	同一个包	不同包的子类	不同包的非子类
private(私有)	Y	N	N	N
default(默认)	Y	Y	N	N
protected(受保护的)	Y	Y	Y	N
public(公开)	Y	Y	Y	Y

重写

1. 概述：子类中出现了和父类一模一样(名字，参数列表一模一样)的方法。延续父类的功能，又在此基础上增加了自己的特有内容，进行功能扩展增强。

 例如：手机可以发短信，打电话，智能手机可以使用微信短信，打视频电话。这里智能手机就是手机的子类，在手机原有发短信，打电话的功能基础上，增加了用微信发短信，打视频电话的功能

//手机类
public class Phone { 
    public void sendMessage(){ 
        System.out.println("发短信"); 
    }
    public void call(){ 
        System.out.println("打电话"); 
    } 
}

//智能手机类
public class SmartPhone extends Phone { 

    @Override//对父类的成员方法进行重写 
    public void sendMessage() { 
        super.sendMessage();//通过super调用了父类中的方法 
        System.out.println("用微信发信息"); 
    }

    @Override//对父类的成员方法进行重写 
    public void call() { 
        super.call(); 
        System.out.println("打视频电话"); 
    }

//测试 
    public static void main(String[] args) { 
        //创建子类对象 
        SmartPhone sp=new SmartPhone(); 
        //调用从父类重写过来的方法 
        sp.call(); 
        sp.sendMessage(); 
    } 
}

@Override注解的作用

1. 1.表示该方法是重写的是父类中的方法。
2. 2.检查重写过后的方法是否符合要求
3. 注意事项：
4. 1.私有的方法不能被重写
5. 2.子类重写父类方法过后，访问权限不能比父类低。（Public>protected>default）
6. 3.被final、private修饰的成员方法也不能进行重写

final关键字

1. 1.被final修饰的变量，表示该变量的值不可被修改。
2. 2.被final修饰的类，无法被继承。
3. 3.被final修饰的成员方法，无法被子类重写。

代码块

1. 1.静态代码块：类加载的时候去执行里面的代码。
2. 格式：
3. static{
4. 代码;
5. }
6. 2.构造代码块：创建对象的时候去执行，先于构造方法执行。
7. {
9. }

public class Test  {
    //构造方法
    public Test(){
        System.out.println("构造方法");
    }
    //静态代码块
    static {
        System.out.println("这是一个静态代码块");
    }
    //构造代码块
    {
        System.out.println("这是一个构造代码块");
    }

    public static void main(String[] args) {
        new Test();
    }
}

1. 结果：
2. 这是一个静态代码块
3. 这是一个构造代码块
4. 构造方法

多态

指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。

举例：动物吃这个行为，熊猫表现出来是吃竹子。而猫表现出来是吃鱼。

一、多态的三要素

1. 1.有继承关系
2. 2.重写父类方法
3. 3.父类引用指向子类对象（把子类的对象赋给父类类型的引用），即向上转型
4. Dog dog = new Dog();//狗是狗
5. Animal an = new Dog();//狗是动物(向上转型)

二、多态的访问特点

1. 访问成员变量：编译看父类，运行看父类。（在子类中通过父类类型的对象访问变量，须在父类中有声明，且结果是父类成员变量的值）
2. 访问成员方法：编译看父类，运行看子类。（在子类中通过父类类型的对象访问方法，也须在父类中有声明，但是运行的是子类重写的方法）

3. //父类 
   public class Animal { 
   int age=5; 
   public void eat(){ 
   System.out.println("动物能干饭"); 
   }
   public void sleep(){ 
   System.out.println("动物要睡觉！"); 
   } 
   }
   
   //子类 
   public class Dog extends Animal { 
   //子类特有的属性值 
   int age=10; 
   String name="大黄"; 
   //重写父类中eat方法 
   @Override 
   public void eat() { 
   System.out.println("狗狗吃骨头"); 
   }
   //狗特有的行为 
   public void lookHome(){ 
   System.out.println("狗狗能看家"); 
   }
   public static void main(String[] args) { 
   Animal a=new Dog(); 
   //访问成员变量:编译看父类，运行看父类 
   //System.out.println(a.name);编译失败，父类中没有该属性 
   System.out.println(a.age);//编译成功，运行的是父类中的age 
   //访问成员方法：编译看父类，运行看子类 
   a.eat();//编译成功，运行的是子类中的方法 
   //a.lookHome();编译错误，父类中没有该方法 
   } 
   }

三、多态的特点

1. 优点：提高了程序的扩展性
2. 缺点：不能使用子类特有的属性和方法

四、多态的转型

1. 1.向上转型：父类引用指向子类对象
2. 2.向下转型：父类引用转换为子类对象。可以调用子类中特有的方法。前提是先要向上转型。

//向上转型 
Animal a=new Dog(); 
//向下转型 
Dog dog=(Dog)a; //强制转换
//此时通过dog引用就可以调用到子类中特有的属性了

抽象类

1. 如果一个方法不能具体地表现出它的行为，那么方法是抽象的。
2. 例如:动物吃东西这个行为，我们无法去具体地表示出动物具体吃什么，说明该行为是抽象的。

一、抽象方法的定义

1、使用abstract关键字去修饰的一个方法表示该方法是抽象方法。

//格式 
public abstract 返回值类型 方法名(参数);

2、抽象方法的三个特征：

①抽象方法没有方法体，只声明。

②抽象方法必须存在于抽象类中。

③不能使用private和static修饰。

注：使用abstract去修饰抽象方法时，不能使用private修饰，因为抽象方法要执行就必须使用子类去重写，使用private将无法重写，就没有了意义。

二、抽象类的定义

1、使用abstract关键字修饰的类为抽象类。

//格式 
public abstract class 类名 

2、抽象类的特征：

①如果类里面，有一个方法是抽象的，那么该类就必须是抽象类。

②抽象类中既可以有抽象方法，也可以有具体的方法。

③抽象类不能实例化，就是不能使用new去创建对象。

④抽象类中，可以有构造方法，用于子类创建对象时初始化父类成员。

⑤抽象类的子类，必须重写抽象父类中中的所有抽象方法。

⑥如果抽象类的子类也是抽象类，则不需要重写父类中的抽象方法

接口

一、概念

1. 接口是一个公共的规范，只要符合规范标准，大家都可以使用，就像一个类一样，一个接口也能够拥有方法和属性
2. 1、接口的特点
3. ①接口相当于指明了一个类必须要做什么和不能做什么，相当于类的蓝图。
4. ②一个接口就是描述一种能力，比如把歌手比作成一个接口，那你要成为一个歌手那就要去实现会唱歌这个技能。所以接口的作用就是在告诉类，你要实现某个接口，就必须实现接口中的方法，我才承认你确实拥有该接口的能力。
5. 2、为什么要使用接口
6. ①接口提供了一个公共的规范。
7. ②接口弥补了Java不能多继承这个局限。
8. ③接口可以实现解耦

二、接口的使用

使用interface关键字

//格式 
public interface 接口名{}

1. 1、接口的属性特点
2. ①接口中声明的变量默认都是public static final修饰。
3. ②接口中声明的方法默认都是public abstract修饰的抽象方法，因此没有方法体。
4. (jdk1.8)后可以在接口中定义非抽象方法，使用default去修饰)
5. ③在接口中没有构造方法
6. 2、实现一个接口
7. 使用implements关键字，实现类必须重写接口里面所有的抽象方法

//格式
class 类 implements 接口名{ 
//实现接口中声明的抽象方法 
}

代码示例
//USB接口 
public interface USB { 
String type="3.0"; 
int power=220; 
//读取 
void read(); 
//写入 
void write(); 
}	

//键盘类实现USB接口 
public class KeyBroad implements USB { 
@Override 
public void read() { 
System.out.println("通过USB接口读取到数据"); 
}
@Override 
public void write() { 
System.out.println("通过键盘向USB写入数据"); 
} 
} 

//测试 
public static void main(String[] args) { 
KeyBroad key = new KeyBroad(); 
key.read(); 
key.write(); 
USB usb=new KeyBroad(); 
usb.read(); 
usb.write(); 
}

3、接口和类的区别

①类只能单继承，只能继承一个父类。

②接口可以多实现，一个接口可以实现多个接口。

③一个类可以继承一个父类，同时实现多个接口。