大数据笔记六

• 一、private的使用
  • 通过对象直接访问成员变量，这样操作会引起数据的安全问题;
    考虑能不能不让外界直接访问对象的成员变量？？？
  • 使用private解决：
  • private：
    • （1）是一个修饰符，
      （2）可以修饰成员变量，也可以修饰成员方法;
      （3）被private修饰的成员只能在本类中被访问。
      （4）提供相应的getXxx()方法和setXxx()方法，用于获取和设置成员变量的值;方法用public修饰;

• 例句：
  package com.until.day06;
   public class Student {
    //成员变量
   private String name;
   public String getName() {
    return name;
   }
   public void setName(String name) {
    this.name = name;
   }
   private int age;
   public int getAge(){
    return age;
   }
  public void setAge(int age){
    if(age < 0 || age > 120){
    	System.out.println("年龄不合法");
    }
    else{
    	this.age = age;
    }		 
  }	
  //成员方法
  public void printInfo(){
    System.out.println("姓名：" + name + ",年龄：" + age);
   }
  }
  

• package com.until.day06;
    public class StudentTest {
     public static void main(String[] args) {
      Student student = new Student();
      String name = student.getName();
      student.setName("张无忌");		
      student.setAge(56);
      int age = student.getAge();
      student.printInfo();
   }
  }
  

• 二、接口
  • （一）接口的概述：
    • （1）接口可以看成是特殊的抽象类，即值包含有抽象方法的抽象类;
    • （2）注意：通过interface关键字定义接口;
      接口不可以定义成员变量，但可以定义常量（常量用大写字母表示）;
      接口中只可以定义没有实现的方法（可以省略public abstract）;
  • （二）接口的实现：
    • （1）与继承不同，一个类可以实现多个接口，实现的接口直接用逗号分隔。当然，该类需要实现这些接口中定义的所有方法;
    • （2）一个类可以通过implements关键字“实现接口”，一个类实现了某个接口后必须实现该接口中定义的方法。
    • （3）接口间可以存在继承关系，一个接口可以通过extends关键字继承另外一个接口。子接口继承了父接口中定义的所有方法。

•  例句：
  interface A{
   public void run();
   }
  interface B extends A{
   public void hunt();
   }
  class C implements B{
   public void run(){}
   public void hunt(){}
  }
  

• （三）接口的优点
  • （1）类与接口的关系，实现关系，而且是多实现，一个类可以实现多个接口，
    类与类之间是继承关系，Java中的继承是单一继承，一个类只能有一个父类，打破了继承的局限性。
  • （2）对外提供规则（USB接口）。
  • （3）降低了程序的的耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发的效率）。
• 三、抽象类：
  • （1）abstract： 关键字，用于修饰方法和修饰类；
    （2）抽象方法：不同类的方法是相似的，但是具体的实现内容不一样；
    所以我们只能抽取它的声明，没有具体的方法体。
    （3）抽象类：有抽象方法的类就是抽象类。
    （4）一个类继承了抽象类，需要重写抽象类中的抽象方法；
  • （5）抽象类的特点：
    1、抽象方法只能放在抽象类中；
    2、抽象类和抽象方法都是被abstract修饰的；
    3、抽象类不能创建对象（不能被实例化）；
    4、抽象类中可以有非抽象方法的；
    5、抽象类和类的关系是继承关系；
    6、如果一个类继承了抽象类，要么就重写所有的抽象方法，要么就它本身设置为抽象类；

  • 例句：员工：
    需求：
    1、公司中
    程序员（programmer）：姓名，年龄，工号，工资，工作；
    项目经理（manager）：姓名，年龄，工号，工资，奖金，工作；	
    package com.until.day06;
    public class Abstract2 {
      public static void main(String[] args) {
      programmer1 s=new programmer1("张三",19,3500,"001");
      s.write();
      s.printInfo();			
     }
    }
    
    abstract	class  employee{
     String name;
     int age;
     int pay;
     String number;
     public void printInfo(){
      	System.out.println("姓名"+name+"年龄"+age+"工资"+pay+"工号"+number);		
     }
     } 
     
    class programmer1 extends  employee{			   
     public  programmer1(String name,int age,int pay,String number){
         this.name=name;
         this.age=age;
         this.pay=pay;
         this.number=number;
     }
        public void write() {
      	   System.out.println("写代码 ");
         }  			 
      }
    
     class manager1 extends  employee{
         double award;
     public  manager1 (String name,int age,int pay,String number,double award){
         this.name=name;
         this.age=age;
         this.pay=pay;
         this.number=number;
         this.award=award;			   
      }
     public void see () {
         System.out.println("看程序员写代码 ");
     }		  
    }