面向对象的三大特性 封装 继承 多态
知识点预览
封装的概念
继承的概念
访问修饰符
方法的覆盖（Override）
super关键字
多态的概念
强制类型转换与instanceof关键字
封装的概念
1. 什么是封装
通过边界将内部组成部分与外部分开
2. 封装的好处
a) 提高一个物体内部组成部分的安全性
b) 向外部屏蔽物体内部组成部分的差异
私有访问修饰符 private
2个方法 获得 设置
3. 封装的内容
a) 属性----->必须
b) 方法根据需要封装
c) 方法声明公开方法实现封装 ------->思想
继承的概念
1. 什么是继承
2. 继承的语法
a) extends关键字;
b) 继承的好处：提高代码的复用性
3. 子类对象的扩展
4. Java语言中继承的特点
a) Java语言中继承是单继承（最多有一个直接父类）
b) Java中单继承的好处
几何拓扑：树状结构较简单 易于实现
5. 继承关系在内存中的表现形式
JVM开辟连续的存储空间（父类、子类）
6. 对象的创建过程\
new Dog();
a) 分配空间（父类对象空间 子类对象空间）
b)
初始化属性
递归的构造父类对象
调用构造方法
c) 初始化属性
d) 调用构造方法
Java中的访问修饰符
1. 什么是Java中的访问修饰符式
private
public
default
protected
2. Java中的访问修饰符
方法的覆盖（Override）
1. 什么是方法的覆盖
子类对从父类继承的方法重新实现
2. 方法覆盖的要求
a) 子类覆盖方法的访问修饰符范围必须大于或者等于父类对应方法的访问修饰符范围
b) 子类覆盖方法的返回值类型必须和父类方法一致
c) 覆盖方法的参数必须和父类方法一致
super关键字
1. super代表父类对象
a) super.属性
子类、父类出现同名，子类中访问父类属性
b) super();
在付了构造方法中调用父类构造方法
2.super()总结
a) 每一个子类的构造方法没有显示调用super()，系统都会提供一个默认的super();（子类编译完后 编译器默认加上super()，调用无参构造）
b) super()书写在第一行;
c) 可以在父类构造方法红枣年糕显示调用super()实现对特定父类构造方法的调用。
3. super思考题
TestSuper4
package chp7.ex11;
/**
*
* 说明：本程序演示了super关键字的使用
*/
public class TestSuper4 {
public static void main(String args[]){
// Dog d = new Dog();
}
}
//这段程序会报错 因为Dog里没写任何代码 有一个系统默认添加的空的构造方法 同时会自动加上super() 调用父类的无参构造方法
//因父类有带参的构造方法 所以会把系统默认的覆盖 所以会报错 Implicit super constructor Animal() is undefined for default constructor. Must define an explicit constructor
//解决办法：在父类添加无参构造方法 这也是编程需要坚持的原则和习惯
/*
class Animal {
String sex ;
public Animal(String sex){
this.sex = sex;
}
//解决办法
//public Animal(){}
}
class Dog extends Animal{
}
*/
多态的概念
1. 什么是多态（父类的引用指向子类的对象）
Dog d = newDog();
Animal a = newDog();
a.call();//错误
2. 多态的特点
a) 对象类型不可变，引用类型可变
b) 只能调用引用其引用类型中定义的方法
c) 运行时会运行子类覆盖的方法
TestPloy
package chp7.ex12;
/**
*
* 说明：本程序演示了多态的使用
*/
public class TestPoly {
public static void main(String args[]){
Animal a = new Dog();//父类的引用指向子类的对象
a.eat();
a.sleep();
//a.call();//The method call() is undefined for the type Animal
}
}
class Animal{
public void eat(){
System.out.println("eat food");
}
public void sleep(){
System.out.println("sleep 8 hours");
}
}
class Dog extends Animal{
public void sleep(){
System.out.println("sleep 6 hours");
}
public void call(){
System.out.println("call ... ");
}
}
class Cat extends Animal{
}
3.多态的作用
提高代码的通用性
Animal a = newDog();
a.sleep();
a.eat();
a = new Cat();
……
Animal [] a =new Animal[2];
a[0] = newDog();
a[1] = newCat();
package chp7.ex14;
/**
*
* 说明：本程序演示了多态的好处：提高代码的通用性
*/
public class TestPoly2 {
public static void main(String args[]){
Animal[] a = new Animal[2];
a[0] = new Dog();
a[1] = new Cat();
for(int i=0;i<a.length;i++){
a[i].eat();
}
}
}
class Animal{
public void eat(){
System.out.println("eat food");
}
public void sleep(){
System.out.println("sleep 8 hours");
}
}
class Dog extends Animal{
public void sleep(){
System.out.println("sleep 6 hours");
}
public void call(){
System.out.println("call ... ");
}
}
class Cat extends Animal{
}
package chp7.ex15;
/**
*
* 说明：本程序演示了多态的好处：提高代码的通用性
*/
public class TestPoly1 {
public static void main(String args[]){
Dog d = new Dog();
eat(d);
Cat c = new Cat();
eat(c);
}
public static void eat(Animal a){
a.eat();
}
}
package chp7.ex15;
/**
*
* 说明：本程序演示了多态的好处：提高代码的通用性
*/
public class TestPoly2 {
public static void main(String args[]){
Animal a = getAnimal(0);
a.eat();
}
public static Animal getAnimal(int i){
if(i==0) {return new Dog();}
else{return new Cat();}
}
}
class Animal{
public void eat(){
System.out.println("eat food");
}
public void sleep(){
System.out.println("sleep 8 hours");
}
}
class Dog extends Animal{
public void sleep(){
System.out.println("sleep 6 hours");
}
public void call(){
System.out.println("call ... ");
}
}
class Cat extends Animal{
}
强制类型转换
把父类转换成子类
Animal a= new Dog();
Dog d = a;//错误把动物看成狗 存在潜在风险
Dog d = (Dog)a;//正确
instanceof运算符
判断对象是否是这个类型
if(a instanceofDog){
Dog d = (Dog)a;
}