Kelas Java, enkapsulasi, kaedah yang diwarisi

Apakah itu ahli kelas

Kaedah ahli dan pembolehubah ahli yang diubah suai dengan statik dipanggil ahli kelas

Pembolehubah ahli yang diubah suai dengan statik dipanggil pembolehubah kelas

Gunakan pengubahsuaian statik Ahli kaedah dipanggil kaedah kelas

Apakah itu pembolehubah contoh

Kaedah ahli dan pembolehubah ahli yang tidak diubah suai dengan statik dipanggil ahli contoh

Pembolehubah ahli yang tidak diubah suai dengan statik dipanggil pembolehubah Instance

Kaedah ahli yang tidak diubah suai dengan statik dipanggil kaedah instance

Contohnya:

public String name;  //这个就是实例成员（属性） 
public static int age;//这个就是类成员（属性） 

public void a(){
	System.out.println("我叫："+this.name)
}                                    //这个没有加static的方法就是实例方法

public static void a(){           	//这个加了static的方法就是类方法
	System.out.println("我叫："+this.name)
}

Jadi apakah perbezaan antara pembolehubah instance dan pembolehubah kelas?

• Semua objek kelas ini berkongsi pembolehubah kelas yang sama, tetapi setiap objek akan mempunyai pembolehubah contoh uniknya sendiri

• Semua objek kelas ini Objek boleh menukar nilai pembolehubah kelas, tetapi setiap objek hanya boleh menukar nilai pembolehubah contoh sendiri

• Pembolehubah tika mesti mencipta objek sebelum menggunakannya dan menggunakannya mengikut nama objek. Nama pembolehubah , tetapi pembolehubah kelas tidak perlu mencipta objek

//定义一个类
public class stu {
    public String name;  //这个类有一个名字这个属性，属于实例成员，也就是需要实例化对象了才可以使用
    //定义构造方法
    public stu(){}    //不管怎么样，都定义一个无参构造
    public stu(String name){    //定义有参构造，需要传入一个字符串名字
       this.name = name;         //这里若不使用this 关键字，那么是不会与上面的实例属性匹配
    }
    //定义方法
    public void a(){
        System.out.println(this.name);
    }
}

Gunakan kelas ini:

public class stu_Test {
    public static void main(String[] args) {
        //实例化两个对象，基于stu类
        stu s1 = new stu("小红");   
        stu s2 = new stu("小王");
        //使用stu类里面的方法
        s1.a();
        s2.a();
    }
    
    //stu s1 = new stu("小红");  将会输出小红
    //stu s2 = new stu("小王");  将会输出小王
}
//通过这个就可以明白每个对象都有属于自己的实例变量（属性）

Jadi apakah perbezaan antara kaedah kelas dan kaedah contoh ?

• Semua objek kelas ini berkongsi kaedah kelas dan kaedah contoh

• Kaedah kelas boleh dipanggil menggunakan nama kelas.Nama kaedah ([ parameter]) , tidak perlu menggunakan

• selepas membuat seketika objek Kaedah contoh menggunakan nama kaedah ([parameter]) untuk memanggil

kata kunci statik

Kelas Java menyediakan dua jenis pembolehubah: pembolehubah statik diubah suai dengan kata kunci statik dan pembolehubah contoh tanpa kata kunci statik. Pembolehubah statik tergolong dalam kelas dan hanya mempunyai satu salinan dalam ingatan Selagi kelas di mana pembolehubah statik berada dimuatkan, pembolehubah statik akan diperuntukkan ruang, jadi ia boleh digunakan. Terdapat dua cara untuk merujuk pembolehubah statik, iaitu "pembolehubah class.static" dan "object.static variable"

kaedah ahli statik:

• kaedah statik ialah kaedah Kelas boleh dipanggil tanpa mencipta objek, manakala kaedah bukan statik ialah kaedah objek dan hanya boleh digunakan selepas objek dicipta

• ini tidak boleh digunakan dalam kaedah statik Dengan kata kunci super, kaedah bukan statik tidak boleh dipanggil, dan hanya pembolehubah ahli statik dan kaedah ahli kelas yang mereka milik boleh diakses, kerana apabila kaedah statik dipanggil, objek kelas ini mungkin belum dicipta lagi telah dicipta, ia tidak boleh Menentukan kaedah objek yang hendak dipanggil.

kegunaan statik:

• Ubah suai pembolehubah ahli

• Ubah suai kaedah ahli

• Blok kod statik

• Kelas yang diubah suai [hanya boleh mengubah suai kelas dalaman, iaitu kelas dalaman statik]

• Import statik Nota pada pakej

statik: Statik hanya boleh mengakses statik, bukan statik boleh mengakses kedua-dua bukan statik dan statik.

Pengenkapsulan:

Konsep pengekapan

Merangkum perkara objektif ke dalam kelas abstrak, dan kelas boleh menggunakan atribut dan kaedah mereka sendiri untuk hanya kelas atau objek yang dipercayai disembunyikan daripada kelas atau objek yang tidak dipercayai Proses ini dipanggil enkapsulasi. Ringkasnya: Tutup maklumat anda dan hanya biarkan orang yang anda percayai melihat dan menggunakannya

Klasifikasi berkapsul

• Pengenkapsulan atribut: Tetapkan atribut adalah peribadi (peribadi), mengehadkan. penggunaannya hanya dalam kelas

• Enkapsulasi kaedah: Untuk pengkapsulan kaedah, tetapkan kaedah yang boleh diakses secara luaran kepada awam dan jadikan ia tidak boleh diakses dari luar Kaedah ini ditetapkan kepada peribadi

  //给name这个属性进行封装
  private Strint name; //即可，这也我们在类外是找不到这个属性的存在的

Memandangkan ia dirangkumkan, mesti ada cara untuk mengubah suai dan menggunakan enkapsulasi ini Ya, ini ialah kaedah get/set

kaedah get/set

public class stu {
    private String name; 
    public void setName(String name){    //set方法：对象调用这个方法，即可对私有属性进行修改
        this.name = name;   
    }
    public String getName(){         //get方法：对象调用这个方法，就可以使用该方法
        return name;
    }
}

Gunakan:

public class stu_Test {
    public static void main(String[] args) {
    stu s =new stu();
    s.setName("小红");  //给name 这个私有属性修改值为小红
        System.out.println(s.getName());
   
}

//Selepas program dijalankan, nilai output ialah Xiaohong

Warisan:

Apakah warisan

1: Kelas baharu boleh diperoleh daripada kelas sedia ada dipanggil warisan

2: Dalam proses pewarisan, kelas baharu dipanggil subkelas, kelas sedia ada dipanggil kelas induk, dan subkelas akan Mewarisi sifat dan tingkah laku kelas induk.

Sintaks warisan:

public class stu extends Student{   //在类名后加上extends，在写上继承的父类即可
//这里可以写父类没有发属性及方法
	public String ID;  //等等等等

}

Nota: Warisan tidak boleh mewarisi sifat peribadi dan kaedah kelas induk! ! ! Selagi ia diubah suai secara peribadi, ia tidak akan diwarisi! ! !

Mengenai subkelas: Selain mempunyai sifat dan kaedah bukan persendirian kelas induk, subkelas juga boleh melanjutkan sifat dan kaedah mereka sendiri

Penggunaan warisan:

Warisan ialah warisan tunggal, iaitu kelas hanya boleh mempunyai satu kelas induk.

Jika kelas tidak mewarisi kelas tertentu secara eksplisit, maka kelas itu mempunyai kelas induk lalai iaitu kelas java.lang.Object
Mewarisi pembolehubah ahli bukan persendirian dan kaedah ahli kelas induk, tetapi sila ambil perhatian: subkelas tidak boleh mewarisi kaedah pembina kelas induk
Ringkasnya: subkelas sahaja Boleh mewarisi kelas induk. Jika kelas ini tidak mewarisi kelas lain, ia akan mewarisi kelas Objek secara lalai (datang dengan Java)

• Tidak boleh mewarisi kaedah pembinaan kelas induk.

  方法的重写：

  @overriding

  什么是方法重写？：

  • 子类根据需求从父类继承的方法进行重新编写（方法名一样）

  • 重写是可以使用super方法的方式来保留父亲的方法（super在后面讲到）

  注意：构造方法不能被重写

  方法重写的规则：

  • 方法名相同，参数列表相同（数量，顺序，数据类型）

  • 如果有返回值，返回值相同或者是其子类，访问权限不能严于父类

  • 父类的静态方法不能被重写为非静态方法，反之父类的非静态方法不能被重写为静态方法

  • 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法**（静态方法中无法使用super、this）**

  • 父类的私有方法不能被子类重写（private修饰的）

  上代码：

  1：定义一个类，有名字和年龄的属性，分别有get/set方法，成员方法是输出名字和年龄:

  public class Person {
      private String name;
      private int age;
  
      //get/ste方法
      public void setName(String name){
          this.name = name;
      }
      public String getName(){
          return name;
      }
  
      public void setAge(int age){
          this.age = age;
      }
      public int getAge(){
          return age;
      }
      //成员方法：
      public void print(){
          System.out.println("我叫："+this.name+","+"我今年："+this.age+"岁");
      }
  }

  2：写一个类，继承Person类，并且这个类拥有自己的一个sex属性，提供get/set方法 并且重写父类的print方法，输出名字+年龄+性别

  public class child extends Person{
      private String sex;      //这个child类继承了Person类，但也拥有自己的属性 sex性别
      public void setSex(String sex){
          this.sex = sex;
      }
      public String getSex(){
          return sex;
      }
      @Override
      //重写父类方法： 因为父类是输出名字和年龄，这里要输出名字，年龄和性别
      public void print(){
          System.out.println("我叫："+getName()+","+"我今年："+getAge()+"岁"+","+"我是"+sex+"孩子");
      }
  }

  3：新建测试类，测试两个类的继承、重写

  //测试类，
  public class Test {
      public static void main(String[] args) {
          child c = new child();
          c.setName("小红");
          c.setAge(20);
          c.setSex("男");
          c.print();
      }
  }
  //分别执行child继承person的set方法，使用重写后的方法，

  //输出结果为： 我叫：小红,我今年：20岁我是男孩子

  super关键字：

  super代表的是父类对象

  super的使用方式：

  1：super.属性名 用于在子类中调用父类被隐藏的同名实例变量

  2：super([参数列表]) 用于在子类的构造方法中调用父类的构造方法

  注意事项：

  • 每一个子类的构造方法在没有显示调用super()，系统都会提供一个默认的super()

  • super() 书写在第一行

  • 可以在子类构造方法中显示调用super(),完成对特定父类构造方法的调用

  简而言之：super就是调用父亲的属性和方法来使用

  上代码：

  1:新建一个类：定义age为20

  public class super_test {
      public int age=20;
      public void print(){
          System.out.println(this.age);
      }
  }

  2：建第二个类，继承第一个类；

  public class su2 extends super_test{
      public int age = 10;
      @Override
      public void print(){
          System.out.println(super.age);  //这里使用super，意思是使用父类的age
      }
  }

  3：建立测试类：

  public class test {
      public static void main(String[] args) {
      su2 s = new su2();
      s.print();
  	}
  }

  这样输出的就是20，是父类的age

  this与super的区别:

  • super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函 数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）

  • this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的 形参与类中的成员数据同名，这时需用this来指明成员变量名

  • super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其 它构造方法。

  • super()和this()均需放在构造方法内第一行,尽管可以用this调用一个构造器，但却不能调用两个

  • this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造 函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意 义，编译器也不会通过。

  • this()和super()都指的是对象，所以，均不可以在static环境中使用。包括： static变量,static方法，static语句块。

  • 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

Atas ialah kandungan terperinci Kelas Java, enkapsulasi, kaedah yang diwarisi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!