Java语言程序设计——篇七（2）

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

封装性与访问修饰符

对象的封装

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

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