🌿🌿🌿跟随博主脚步，从这里开始→博主主页🌿🌿🌿
封装性与多态
- 封装性与访问修饰符
- 类的访问权限
- 类成员的访问权限
- 🌠防止类扩展和方法覆盖
- 实战演练
- 抽象类
- 实战演练
- 对象转换
- 实战演练
- instanceof运算符
- 多态与动态绑定
- 实战演练
- 实战演练
封装性与访问修饰符
对象的封装
- 通过包实现封装性
包是JAVA中最大的封装单位，定义了成员的访问权限。 - 通过类和类的成员访问权限实现
比如：private
类的访问权限
类的访问权限通过修饰符public实现，若缺省访问修饰符的类仅能被同一个包的类使用
package com.demo;
public class Employee {
public Employee(){
System.out.println("创建Employee对象");
}
}
package com.xxxxx;
import com.demo.Employee;
public class EmployeeTest {
public static void main(String[] args){
Employee emp = new Employee();
}
}
不在同一个包中，需要import导入。若同一包中，则不需要
类成员的访问权限
类成员的访问权限包含成员变量和成员方法的访问权限
(1) private:私有成员，只能本类访问，最能体现封装性，实现隐藏
(2) protected:保护成员，可以被类本身访问；也可以被同一包中的类以及该类的子类访问
(3) public:公共成员，可以被任何其他类访问
(4) 缺省:包可访问的，成员被本类或同一个包中的类访问。
🌠防止类扩展和方法覆盖
- 使用final修饰类，该类(public final class EmployeeTest {}
该类为最终类，不能被继承) 就成了最终类 （不能被继承） - 如果用final来修饰类的成员，则该成员为最终成员。
- 若父类的成员不希望被子类的成员所覆盖，则可将它们声明为final。final成员可被继承，但不能被覆盖。
- 成员变量若同时被static和final修饰，则表示常量，若没有初始化则按默认值初始化。
- 仅用final不用static修饰则必须且只能赋值一次，不能默认。方式：定义时赋值；构造方法赋值。
实战演练
public final class Parent {}
public class Parent {
public final void setXY(int x,int y){}
}
public class Child extends Parent{
public void setXY(int x,int y){}
}
出现错误
public static final int Size = 10;
int data
public void add(){
Size = Size + 1;
data = data + Size;
}
出现错误
抽象类
抽象类有点类似“模板”的作用，其目的是根据它的格式来创建和修改新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的子类，再由其子类来创建对象。即，抽象类就是不能用new运算符来创建实例对象的类，它可以作为父类被它的所有子类所共享。
- 抽象类的定义格式：
abstract class 类名
{
声明成员变量；
返回值的数据类型 方法名（参数表）
{
……
}
abstract 返回值的数据类型 方法名（参数表）；
}
在抽象方法里，不能定义方法体。只需声明不需实现。
说明：
①抽象类的子类必须实现父类中的所有抽象方法，即抽象方法必须被子类的方法所覆盖，或将自己也声明成抽象方法。
②由于抽象类是需要被继承的，所以abstract类不能用final来修饰。也就说，一个类不能既是最终类，又是抽象类，即关键字abstract与final不能合用。
③抽象类中不一定包含抽象方法，但包含抽象方法的类一定要声明为抽象类。
④抽象类可以有构造方法，且可被子类构造方法所调用，但构造方法不能被声明为抽象的。抽象类不能创建实例，一般情况，不会定义构造方法。
实战演练
【例】抽象类的应用举例，定义一个形状抽象类Shape，以该抽象类为父类派生出圆形子类Circle和矩形子类Rectangle。
abstract class Shape
{
protected String name;
public Shape(String xm)
{
name=xm;
System.out.print("名称："+name);
}
abstract public double getArea();
abstract public double getLength();
}
class Circle extends Shape
{
private final double PI=3.14;
private double radius;
public Circle(String shapeName, double r)
{
super(shapeName);
radius=r;
}
public double getArea()
{ return PI*radius*radius; }
public double getLength()
{ return 2*PI*radius; }
}
class Rectangle extends Shape
{
private double width;
private double height;
public Rectangle(String shapeName,double width,double height)
{
super(shapeName);
this.width=width;
this.height=height;
}
public double getArea()
{ return width*height; }
public double getLength()
{ return 2*(width+height); }
}
public class App {
public static void main(String[] args){
Shape rect =new Rectangle("长方形",6.5,10.3);
System.out.print("；面积="+rect.getArea());
System.out.println("；周长="+rect.getLength());
Shape circle=new Circle("圆",10.2);
System.out.print("；面积="+circle.getArea());
System.out.println("；周长="+circle.getLength());
}
}
运行结果：
对象转换
对象转换：子类对象与父类对象在一定条件下可以相互转换。
实战演练
【例】类的继承，创建Person类，再以该类为父类创建一个子类Employee。（回顾）
public class Person {
public String name;
public int age;
public Person(){}
public Person(String name, int age){
this.name = name;
this.age = age;
}
public void sayHello(){
System.out.println("My name is"+name);
}
}
public class Employee extends Person {
public double salary;
public Employee(){}
public Employee(double salary){
this.salary = salary;
}
public Employee(String name,int age, double salary){
super(name,age);
this.salary = salary;
}
public double computeSalary(int hours, double rate){
double salary = hours * rate;
return this.salary + salary;
}
}
【例】对象转换
public class EmployeeTest {
public static void main(String[] args){
Employee emp = new Employee("李菲菲",23,5000);
System.out.println(emp);
Person p = emp;
System.out.println(p);
p.sayHello();
Employee yy = (Employee)p;
System.out.println(yy.computeSalary(10, 50.0));
}
}
instanceof运算符
对象运算符instanceof
可利用对象运算符instanceof在运行时来测试一个指定对象是否是指定类或它的子类的实例，若是则返回true，否则返回false。
class Person { }
class Man extends Person{ }
Person p1 = new Person();
Person p2 = new Man();
Man m1 = new Man();
System.out.println(p1 instanceof Man);//false
System.out.println(p2 instanceof Man);//true
System.out.println(m1 instanceof Man);//true
多态与动态绑定
- 多态 某种抽象的动作由特定的方式实现，特定的方式取决于执行该动作的对象。
- 可以简单理解为多态就是“相同的表达式，不同的操作”或“相同的命令，不同的操作”
多态分为：
①静态多态----重载实现
②动态多态----覆盖实现
实战演练
多态与动态绑定----动态多态
public class Person {
public String name;
public void sayHello(){
System.out.println("My name is"+name);
}
public void sayHello(String s){
System.out.println("My name is"+s);
}
public void sayHello(String s,int ss){
for(int i = 0; i < ss; i++)
System.out.println("My name is"+s);
}
}
实战演练
多态与动态绑定----静态多态
public class Animal{
public abstract void eat(){}
}
public class Dog extends Animal{
public void eat(){
System.out.println(“eat bone！");
}
}
public class Cat extends Animal{
public void eat(){
System.out.println(“eat fish！");
}
}
博主用心写，读者点关注，互动传真情，知识不迷路
![[练习]如何使用递归算法？](https://i-blog.csdnimg.cn/direct/def5ae877ca24e509b574aff520f0778.jpeg)
