封装特性
- 封装性产生的目：保护某些属性和方法不被外部所看见
- 封装性的实现：为属性和方法进行封装是通过关键字 private 声明的
- 如果某封装属性想被外部所访问，可为该属性设置 set 和 get 方法
匿名对象
- 匿名对象就是没有名字的对象，如果程序中只用一次对象，就可以使用对象的方法
- 匿名对象执行后会被 JC 垃圾回收机制自动回收
class A{
public void say() {
}
}
public class Demo3 {
public static void main(String[] args) {
new A().say();//一次性使用
}
}
继承特性
- 基本概念：扩展父类的功能
- 关键字 ：extends 例如： class 子类 extends 父类
继承的限制
- Java 中只允许单继承，也就是说只能继承一个父类，但是可以实现多个接口
- 子类不能直接访问其父类的私有成员，可以通过 set 与 get 方法来访问
方法覆盖
- 方法名相同，参数类型或者个数不同
- 对权限没有要求
- 发生在一个类中
- Overloading
方法重写
- 子类实现了父类的某种方法，其方法名、返回类型、参数完全相同。
- 被重写的方法的不能拥有比父类更严格的权限
- 发生在继承中
- Overriding
super 关键字
- 子类对象不会访问被重写了的父类方法，但是可以在子类重写方法中用 super 关键字来强行调用父类的方法
- 构造方法中默认有 super 方法
- super 关键字不一定在重写中使用，也可以表示那些方法从父类中继承而来，从而在其父类中去寻找该方法的原理。
class A{
public void say() {
System.out.println("A->say");
}
}
class B extends A{
public void say() {
super.say();
System.out.println("B->say");
}
}
public class Demo3 {
public static void main(String[] args) {
B b = new B();
b.say();
}
}
多态特性
向上转型与向下转型
- 向上转型：创建子类对象却分配给父类实例
eg: 父类 父类实例 = new 子类（）； - 向下转型：必须先向上转型之后才能使用向下转型
eg: 子类 子类实例 = （子类）父类实例；
什么是多态
- 顾名思义就是多种状态，在一定程度上让代码更具有灵活性。
- 所谓多态，就是指一个引用（类型）在不同情况下的多种状态；也可以理解为，多态是通过指向父类的指针，来调用不同子类中实现的方法。
- 理解了向上转型与向下转型之后，再讨论多态就好理解了，先看下面的代码：
public class Demo3 {
public static void main(String[] args) {// TODO Auto-generated method stub
//向上转型
Animal an = new Dog();
an.say(); //通过指向父类的指针去调用子类已实现的方法
an.tell1();
//向下转型
Cat cat = (Cat) an;
cat.say();
cat.tell1;
}
}
class Animal{
public void say(){
System.out.println("我是动物");
}
public void tell1(){
System.out.println("动物在说话");
}
}
class Dog extends Animal{
//覆盖父类方法
public void say() {
System.out.println("我是狗");
}
public void tell2(){
System.out.println("狗在发声");
}
}
class Cat extends Animal{
public void say() {
System.out.println("我是猫");
}
}
其输出为：
我是狗
动物在说话
我是猫
动物在说话
具体应用分析
public class Demo2 {
public static void main(String[] args) {
Manager manager = new Manager();
// new 子类，通过指向父类的指针来调用子类中实现的方法
manager.feed(new Dog(), new Bone("骨头"));
manager.feed(new Cat(), new Fish("鱼"));
manager.feed(new smallDog(), new smallBone("小骨头"));
}
}
//管理员
class Manager{
//声明一个一个方法，其参数都是父类的引用，在main函数调用时传的值为具体的子类
public void feed(Animal an,Food food){
an.eat(food);
food.showFood(food);
}
}
//食物类
class Food{
//构造方法
public Food(String name) {
this.name = name;
}
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void showFood(Food food){
System.out.println("我是"+ food.getName());
}
}
//鱼类
class Fish extends Food{
//继承带有构造方法的父类必须实现其够着方法
public Fish(String name) {
super(name);
}
public void showFood(Food food) {
System.out.println("我是" + food.getName());
}
}
//骨头类
class Bone extends Food{
public Bone(String name) {
super(name);
}
public void showFood(Food food) {
System.out.println("我是" + food.getName());
}
}
//孙子骨头类
class smallBone extends Bone{
public smallBone(String name) {
super(name);
}
public void showFood(Food food) {
System.out.println("我是" + food.getName());
}
}
//动物类
class Animal{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(Food food) {
System.out.println("我吃" + food.getName());
}
}
//狗类
class Dog extends Animal{
public void eat(Food food){
System.out.println("狗吃" + food.getName());
}
}
//猫类
class Cat extends Animal{
public void eat(Food food) {
System.out.println("猫吃" + food.getName());
}
}
//孙子狗类
class smallDog extends Dog{
public void eat(Food food){
System.out.println("小狗狗吃" + food.getName() );
}
}
其输出为：
够吃骨头
我是骨头
猫吃鱼
我是鱼
小狗狗吃骨头
我是小骨头
instanceof 关键字
- 可以通过 instanceof 关键字判断一个对象到底是不是一个类的实例
public class Demo3 {
public static void main(String[] args) {// TODO Auto-generated method stub
//向上转型
A a = new A();
System.out.println(a instanceof A);//输出true
System.out.println(a instanceof B);//输出false
A a1 = new B();
System.out.println(a1 instanceof A);//输出true
System.out.println(a1 instanceof B);//输出true
}
}
class A{
}
class B extends A{}
- 通过上述代码例子，可以发现其父类的对象不会是其子类的实例，但是其子类的对象可以是父列的实例
