Java学习第七天

使用private修饰符对属性进行修饰,限制属性的访问的权限,该属性只能由内部访问,其他类无法通过对象.属性访问,从而实现对对象的状态(数据)进行保护,外部要访问需通过get,set进行访问,保证属性统一性

• 学生类Student

  属性用private修饰

  提供get,set方法访问属性,set可以限制赋值内容,get返回转换后的指定格式数据

  转换和限制等逻辑都是封装在方法中

  package Java面向对象.第七天;
  
  public class Student {
      private String name;
      private int sex;
      private int age;
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public String getSex() {
          return sex==1?"男":"女";
      }
  
      public void setSex(int sex) {
          if (sex>1||sex<0){
              throw new RuntimeException("只能是1或0");
          }
          this.sex = sex;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  }
  

• 使用学生类

  使用学生类不能直接访问属性,必须通过get,set方法

  如果赋值不符合,就会异常

  用get方法读取属性,会读到学生类中转换后的内容(1转男,0转女)

  package Java面向对象.第七天;
  
  public class Test {
      public static void main(String[] args) {
          Student student = new Student();
          //student.name=""小明;//私有成员变量,不能直接用对象.属性访问访问
          student.setName("小明");//私有只能通过get/set方法访问
          student.setAge(22);
          student.setSex(1);
          System.out.println(student.getSex());
      }
  }
  
  

Java中有四种权限修饰符，分别是public，protected，default，private

• private，private是私有的，即只能在当前类中被访问到，它的作用域最小。

• default(默认，缺省的)，也被称为friendly有好的

  ​ 即在成员的前面不写任何的访问修饰符的时候，默认就是友好的。所谓友好的，是对同一package的类友好。

  ​ 同一package中的所有类都能访问。被friendly所修饰的成员只能被该类所在同一个package中的子类所继承下来。(也就是说只有在同一个package中的子类才能访问到父类中friendly修饰的成员)

• protected

  ​ protected是受保护的，受到该类所在的包所保护。

  ​ 被protected所修饰的成员会被位于同一package中的所有类访问到。同时，被protected所修饰的成员也能被该类的所有子类继承下来。(注意：这里是指同一个package或者不同的package中的子类都能访问)

• public

  public是公共的，被public所修饰的成员可以在任何类中都能被访问到。

  ​ public能用来修饰类，在一个Java源文件中只能有一个外部类类被声明为public，而且一旦有一个类为public，那这个Java源文件的文件名就必须要和这个被public所修饰的类的类名相同，否则编译不能通过。

  ​ 另外，一个类作为外部类的时候只能被public或者默认访问修饰符所修饰，但是一个类如果作为内部类的时候，则可以被四种访问修饰符所修饰，因为一个类作为内部类的时候，就作为外部类的一个成员属性了，因此可以有四种访问修饰符修饰，这是内部类和外部类的一个区别。

  ​ public用来修饰类中成员变量、成员方法，被public所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问public成员。

  ​ public在类的继承上的体现，被public所修饰的成员能被所有的子类继承下来。

• 修饰符用在类,成员变量,方法,局部变量不需要修饰符

• 通过外部类创建父类对象

  • private修饰的,不在同一类,不能访问
  • default(缺省)修饰的,不在同一类,不再同一包,不能访问,若在同一包中可以访问
  • protected修饰的,不在同一类,不再同一包,并非继承,通过外部类直接创建父类的对象,该类不能访问此对象中用protected修饰符修饰的属性及方法权限

• 通过继承创建类对象

  • private修饰的,不在同一类,不能访问 对继承的子类是不可见的
  • default(缺省)修饰的,不在同一类,不再同一包,不能访问,default不具备让继承的子类进行访问的权限 对继承的子类是不可见的
  • protected修饰的,不在同一类,不再同一包,有继承,可以访问 对继承的子类可见

• protected修饰符详解

  • protected修饰符,对继承父类的子类是可见的,但通过直接创建父类,以及通过外包类创建继承的子类均不能访问protected修饰的属性和方法,因为protected修饰的父类属性及方法,仅对于外部类继承父类后的外部子类在自身中通过this或实例调用
  • 访问的方式有两种:
    1.在继承的子类中,不能直接(方法除外,但不包括构造方法)通过new自己的方式,访问protected属性及方法,可通过this访问
    2.在继承的子类中,可以在子类的main方法中实例化访问

• 修饰符作用与类
  外部类

  • 由于外部类是需要访问的,所以只能用public以及default修饰符修饰
  • 对于protected修饰符不能用于修饰外部类
    • 例如:你要成为A类的子类，你的先访问到A类，但你要访问到A类，那你先得成为A类的子类。

  内部类

  • 可以用四种修饰符修饰
  • protected修饰符修饰的内部类,如果没有定义构造方法,系统会默认的加一个与内部类同修饰符权限的构造方法

A类通过extends关键词继承B类,继承后A类具有B类的部分属性和方法,提高代码利用率

[修饰符] class 子类 extends父类{

}

• 子类也叫派生类,衍生类,subClass

• 父类也叫基类,超类,superClass

继承特点

• 继承只能是单继承,一个类只能继承一个父类,但可以连续继承Object->A->B->C

• 一个父类可以被多个类继承,例如:Object是所有类的父类

• 继承父类后的子类,可以Override重写(覆盖)父类的方法

• 创建子类对象时,会先执行父类的构造方法,但并没有创建父类对象

父类定义了分别定义一个属性和方法

子类继承父类后,子类具备父类所有属性和方法

子类可以定义自己的属性和方法,也可以重写父类方法[@Override 重写注解 ]

• 父类

  public class 父类 {
      private int a=1;
      public void 父类方法(){
          System.out.println(a);
      }
  }
  
  

• 继承的之类

  public class 子类 extends 父类 {
      父类 父 = new 父类();
      @Override//重写,覆盖父类方法
      public void 父类方法() {
          super.父类方法();
          System.out.println("子类");
      }
  
  }
  

• 运行代码

  public class Test {
      public static void main(String[] args) {
          子类 子= new 子类();
          子.父类方法();
  
      }
  

子类继承父类后,子类对父类的方法进行重写,除访问权限可以不一致外,都必须与父类相同

特征:

• 重写的 返回值,方法名,参数(个数,顺序,类型)都必须与父类一致
• 访问权限修饰符必须与父类相同或者更大
• 如果子类要抛出异常,异常范围必须比父类范围小或者相同

在一个类中(不一定要继承),存在多个方法名相同,但参数列表(参数个数,类型,顺序)存在其中一样不同时,这些方法就称为方法的重载

特性:

• 方法名相同
• 参数列表不相同(个数,类型,顺序)

• 以对象使用

  • this
    • 继承后的子类,可以将this当做子类对象来调用父类的属性和方法
  • super
    • 在子类中,以super作为父类对象来调用父类属性和方法

• 以方法使用

  在子类中

  • 在构造方法中调用构造方法，用this代替构造方法名,但必须写在构造方法内的第一行

  • 子类要调用父类的构造方法，用super()

  • 子类的构造方法会调用父类的无参的构造方法,若父类没有无参构造方法，子类构造方法中必须要调用父类的有参的构造方法