Java面向对象基本特征

Java面向对象基本特征

1、封装性
    一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。
    属性的封装：Java中类的属性的访问权限的默认值是default，要想隐藏该属性或方法，就可以加private（私有）修饰符，来限制只能够在类的内部进行访问。对于类中的私有属性，要对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安全性。
    方法的封装：对于方法的封装，该公开的公开，该隐藏的隐藏。方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），隐藏方法的实现会使实现的改变对架构的影响最小化。
public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        person.tell();
        person.setAge(-20);
        person.setName("张三");
        person.tell();
    }
}
class Person{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>0&&age<150){
            this.age = age;
        }
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    void tell(){
        System.out.println("姓名："+name+";年龄："+age);
    }
}

备注：
（1）Java匿名对象：只需要使用一次的场所。例如：new Person().tell();
     
（2）Java构造方法：构造方法名称必须与类名一致，没有返回指，可以重载，主要为类中的属性初始化。

     
（3）值传递的数据类型：八种基本数据类型和String(String也是传递的地址,只是String对象和其他对象是不同的，String是final的，所以String对象值是不能被改变的，值改变就会产生新对象。那么StringBuffer就可以了，但只是改变其内容，不能改变外部变量所指向的内存地址)。
引用传递的数据类型：除String以外的所有复合数据类型，包括数组、类和接口。
123456789101112131415161718192021222324252627282930 public class TestRef4 {
public static void main(String args[])
  {
    int val=10;;
    StringBuffer str1, str2;   
    str1 = new StringBuffer("apples");
    str2 = new StringBuffer("pears");
     
    System.out.println("val：" + val);
    System.out.println("str1 is " + str1);
    System.out.println("str2 is " + str2); 
    System.out.println("...............................");
     
    modify(val, str1, str2); 
    System.out.println("val is " + val);
    System.out.println("str1 is " + str1);
    System.out.println("str2 is " + str2);
  }
 
  public static void modify(int a, StringBuffer r1,StringBuffer r2)
  {     
      a = 0;
      r1 = null;       
      r2.append(" taste good");
      System.out.println("a is " + a);
      System.out.println("r1 is " + r1);
      System.out.println("r2 is " + r2);
      System.out.println("...............................");
  }
}

输出结果为：
val：10
str1 is apples
str2 is pears
...............................
a is 0
r1 is null
r2 is pears taste good
...............................
val is 10
str1 is apples
str2 is pears taste good

（4）this关键字：表示类中的属性或方法；调用类中的构造方法，例如：this()；表示当前对象。

（5）static关键字：static申明属性为全局属性；static申明方法直接通过类名调用；使用static方法时，只能访问static申明的属性和方法，而非static申明的属性和方法时不能访问。

2、继承性

    在程序中，使用extends关键字让一个类继承另一个类，继承的类为子类，被继承的类为父类，子类会自动继承父类所有的方法和属性
    class 子类 extends 父类{}

示例1：
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Student student=new Student();
        student.setAge(15);
        student.setName("张三");
        student.setScore(90);
        student.tell();
        System.out.println("..............................");
        System.out.println("name："+student.getName()+"；age："+student.getAge()+"；score："+student.getScore());
    }
}
 
class Person{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
 
class Student extends Person{
    //private int age;
    //private String name;
        private int score;
      //public int getAge() {
    //return age;
    //}
    //public void setAge(int age) {
    //this.age = age;
    //}
    //public String getName() {
    //return name;
    //}
    //public void setName(String name) {
    //this.name = name;
        //}
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public void tell(){
        System.out.println("name："+getName()+"；age："+getAge()+"；score："+getScore());
    }
}

输出结果：
name：张三；age：15；score：90
..............................
name：张三；age：15；score：90

2.1 在Java中只允许单继承（一个子类只允许有一个父类），子类不能直接访问父类的私有成员
示例2：

 public class ExtendsDemo2 {
 public static void main(String[] args){
 PetWorker petWorker=new PetWorker();
 petWorker.setAge(20);
 petWorker.setWork("teacher");
 petWorker.tell();
 }
}
/**
 * 创建类People
 * @author Admin
 *
 */
class People{
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
/**
 * 创建Worker类，单继承People类
 * @author Admin
 *
 */
class Worker extends People{
    private String work;
    public String getWork() {
        return work;
    }
    public void setWork(String work) {
        this.work = work;
    }
}
/**
 * 创建PetWorker类，单继承Worker类
 * @author Admin
 *
 */
class PetWorker extends Worker{
    public void tell() {
        System.out.println("age:"+getAge()+";work:"+getWork());
    }
}

输出结果：
age:20;work:teacher

2.2 Java方法重写
  定义：方法名称相同，返回值类型相同，参数也相同，其实质就是子类定义了和父类同名的方法。
  重写限制：被子类重写的方法不能拥有比父类方法更严格的访问权限。private<default<public
  子类调用父类中的方法：super.方法名(参数)
public class ExtendsDemo1 {
    public static void main(String[] args) {   
    B b=new B();
    b.tell();
    }
}
 
class A{
    public void tell(){
      System.out.println("父类中的tell方法");
    }
}
 
class B extends A{
    public void tell() {
    super.tell();
    System.out.println("我重写了tell方法");
    }
    void say(){
    super.tell();
    }
}

输出结果：
  父类中的tell方法
  我重写了tell方法
  父类中的tell方法

2.3 抽象类与接口
  final能申明类、方法和属性，使用final申明的类不能被继承，使用final申明的方法不能被重写，使用final申明的变量变成常量（定义时要赋值），常量是不可以修改的。
  抽象类：包含一个抽象方法的类就是抽象类。
定义：
abstract  class ClassName{
    属性
    方法
    抽象方法
}
（1）抽象方法：申明而未实现的方法，抽象方法必须使用abstract关键字申明，只有方法名和参数，没有方法体。
（2）抽象类被子类继承，子类（若不是抽象类）必须重写抽象类中的所有抽象方法。
（3）抽象类不能实例化，要通过其子类进行实例化。
public class AbstractClassDemo1 {
    public static void main(String[] args) {
        StuClass stuClass=new StuClass();
        stuClass.tell();
        stuClass.say();
    }
}
 
abstract class AbsClass{
    int age;
    public void tell(){
        System.out.println("父类中的tell方法");
    }
    public abstract void say();
}
 
class StuClass extends AbsClass{
    @Override
    public void say() {
        System.out.println("子类实现父类抽象类中的say抽象方法");
    }
}

  接口可以理解为一种特殊的类（没有构造方法），里面全部是由全局常量和公共的抽象方法组成，接口的实现必须通过子类，使用关键字implements，而且子类可以多实现接口。一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口。接口定义如下：
[修饰符] interface 接口名 [extends 父接口名列表]{
    [public] [static] [final] 全局常量;
    [public] [abstract] 抽象方法;
}
样例：

public abstract class InterfaceDemo1 {
    public static void main(String[] args) {
        InterfaceClass interfaceClass=new InterfaceClass();
        interfaceClass.print(1.0f);
    }
}
 
class InterfaceClass implements CalInterface1,CalInterface2{
    @Override
    public void print(float r) {
        System.out.println("半径为"+r+"的圆面积："+getArea(r)+",周长:"+getCircumference(r));
    }
    @Override
    public float getArea(float r) {
        float area=PI*r*r;
    return area;
    }
    @Override
    public float getCircumference(float r) {
        float circumference=2*PI*r; 
    return circumference; 
    }
}
//定义接口CalInterface1
interface CalInterface1 
{
    float PI=3.14159f;//PI默认为public static final类型
    float getArea(float r);//方法getArea()默认为public abstract类型，注意抽象方法没有方法体 
    public abstract float getCircumference(float r);//计算面积
}
//定义接口CalInterface2
interface CalInterface2
{   
    void print(float r);//打印输出结果
}
//定义接口CalInterface3，继承接口CalInterface1和CalInterface2
interface CalInterface3 extends CalInterface1,CalInterface2{
     
}

输出结果：
    半径为1.0的圆面积：3.14159,周长:6.28318

抽象类和接口的对比

（1）如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类。

（2）如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。

（3）如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

 本文永久更新链接地址：