🌿🌿🌿跟随博主脚步，从这里开始→博主主页🌿🌿🌿

封装性与访问修饰符

对象的封装

• 通过包实现封装性
  包是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！");}
}

博主用心写，读者点关注，互动传真情，知识不迷路