Quelles sont les trois fonctionnalités majeures de Java ?-javaDidacticiel-php.cn

Les trois fonctionnalités principales de Java : 1. L'encapsulation, qui fait référence au masquage des propriétés et des détails d'implémentation d'un objet et à la fourniture d'un accès public uniquement à l'extérieur. 2. L'héritage, qui dérive de nouvelles classes à partir de classes existantes, de nouvelles classes peuvent être créées ; absorber les attributs de données et les comportements des classes existantes et peut étendre de nouvelles capacités ;3. Polymorphisme, une méthode peut avoir plusieurs versions d'implémentation, c'est-à-dire « une définition, plusieurs implémentations ».

Quelles sont les trois fonctionnalités majeures de Java ?

Recommandations associées : "Tutoriel vidéo Java"

Les trois fonctionnalités principales de Java sont considérées comme uniques à Java Performances, lorsqu'il s'agit des trois fonctionnalités majeures de Java, nous penserons tous à l'encapsulation, à l'héritage et au polymorphisme, qui sont les fonctionnalités les plus importantes de notre Java.

Encapsulation :

Encapsulation : fait référence au fait de masquer les propriétés et les détails d'implémentation d'un objet et de fournir uniquement un accès public au monde extérieur.

Avantages :

Isolez les changements.
Facile à utiliser.
Améliorer la réutilisabilité.
Améliorer la sécurité.
Principe d'encapsulation :
Masquer le contenu qui n'a pas besoin d'être fourni au monde extérieur.
Masquer toutes les propriétés et fournir des méthodes publiques pour y accéder.

mot-clé privé :

est un modificateur d'autorisation.
Utilisé pour modifier les membres (variables membres et fonctions membres)
Les membres privés ne sont valables que dans cette classe.

L'une des plus couramment utilisées :

Variables de membre privé et fournir l'ensemble correspondant et les méthodes get pour y accéder. Sécurité améliorée de l’accès aux données.

Par exemple :

Le modèle de perte de sang que nous appelons souvent

public class Demo {

        private String name;
        private String sex ;
        private int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getSex() {
            return sex;
        }
        public void setSex(String sex) {
            this.sex = sex;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }


}

Copier après la connexion

Construction de blocs de code et de méthodes de construction (Construct) :

Méthode de construction :

est utilisée pour initialiser l'objet et l'objet correspondant. Il a Ciblé, une des fonctions. .

Caractéristiques :

Le nom de la fonction est le même que le nom de la classe.
Il n'est pas nécessaire de définir le type de valeur de retour.
Cette fonction n'a pas de valeur de retour spécifique.
Le constructeur n'est pas appelé manuellement par nous (l'appel manuel fait référence à b1.baby();), mais lorsque l'objet correspondant est créé, la JVM l'appellera activement pour le constructeur correspondant.
Si une classe n'écrit pas explicitement un constructeur, le compilateur Java ajoutera un constructeur sans paramètre à la classe.
Si une classe a explicitement écrit un constructeur, le compilateur Java n'ajoutera pas de constructeur sans paramètre à la classe.
Plusieurs constructeurs peuvent exister dans une classe sous forme de surcharge de fonctions.
Les méthodes de construction incluent la méthode de construction sans paramètre et la méthode de construction paramétrée. La JVM crée un constructeur sans paramètre par défaut. Si un constructeur paramétré est créé manuellement, le système reconnaîtra le constructeur paramétré par défaut.

构造函数的定义格式： 
   修饰符 函数名(形式参数){
           函数体;
 }
　　修饰符 函数名(){
           函数体;}

Copier après la connexion

La différence entre les méthodes constructeur et les méthodes ordinaires :

(1) La différence dans les types de valeurs de retour :

①Les fonctions de construction n'ont pas de type de valeur de retour. Si void ou d'autres types de valeur de retour sont ajoutés, cela devient une fonction ordinaire, ce qui nous oblige à l'appeler manuellement.

② Les fonctions ordinaires ont un type de valeur de retour Même si la fonction ne renvoie pas de valeur, le type de valeur de retour doit être écrit void.

(2) La différence dans les noms de fonctions :

① Le nom de fonction du constructeur doit être cohérent avec le nom de la classe.

②Le nom de fonction d'une fonction ordinaire doit uniquement respecter les règles de dénomination des identifiants.

(3) La différence dans les méthodes d'appel :

① Le constructeur est appelé par la JVM lors de la création d'un objet.

② Nous appelons les fonctions ordinaires à l'aide d'objets. Un objet peut appeler des fonctions ordinaires plusieurs fois.

(4) Différence de fonction :

① La fonction du constructeur est d'initialiser un objet. Chaque objet créé a une valeur initiale.

② Les fonctions ordinaires sont utilisées pour décrire le comportement public d'une classe de choses.

Remarques :

(1) Le modificateur d'autorisation du constructeur sans paramètre ajouté par le compilateur Java est cohérent avec le modificateur d'autorisation de la classe.

(2) Le constructeur est appelé lors de la création d'un objet, vous pouvez donc transmettre la valeur de l'attribut au constructeur et définir les paramètres dans le constructeur pour recevoir la valeur de l'attribut.

（3）JVM和Java编译器是不同的，Java编译器编译生成的.class文件是给JVM看的，所以经过编译后的class类打开后会是乱码，我们可以通过反编译来查看。

构造代码块：

1.构造代码块的作用与构造函数的作用的对比：

（1）构造代码块的作用：给所有对象进行统一的初始化，对象一建立就运行并且优先于构造函数，比如所有的婴儿出生都会哭。

（2）构造函数的作用：给对应的对象（new ）进行初始化。

构造代码块的格式：

{

构造代码块;

}
注意：构造代码块的大括号必须位于成员的位置上。

Copier après la connexion

代码块的类别：

（1）构造代码块：在工作中经常会用到。

（2）局部代码块：大括号位于方法之内，基本上写不写没什么区别，现实开发中也很少会用到。它的作用是缩短局部变量的生命周期，节省一点点内存。

（3）静态代码块：使用static修饰的代码块。

注意的事项：

（1）Java编译器在编译一个Java源文件的时候，会把成员变量的声明语句提前至一个类的最前端。

（2）成员变量的初始化工作其实都是在构造函数中执行的。

（3）一旦经过Java编译器编译后，那么构造代码块的代码就会被移动到构造函数中执行，构造代码块的代码是在构造函数之前执行的，构造函数中的代码是最后执行的。

（4）成员变量的显示初始化与构造代码块的代码是按照当前代码的顺序执行的。　

继承(inheritance)：

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
在JAVA中，被继承的类叫父类(parent class)或超类(superclass)，继承父类的类叫子类(subclass)或派生类(derivedclass)。因此，子类是父类的一个专门用途的版本，它继承了父类中定义的所有实例变量和方法，并且增加了独特的元素。

继承的结构：

Quelles sont les trois fonctionnalités majeures de Java ?

继承的使用：

关键字：extends。

使用继承
– 编写父类
– 编写子类， 继承父类
class Animal {
//公共的属性和方法
}
class Chicken extends Animal{
//子类特有的属性和方法
}
 class Duck extends Animal {
}

Copier après la connexion

基本语法：

class Chicken extends Animal{ }

Copier après la connexion

上述代码表示Chicken类继承Animal类，使用extends关键词将Animal类（父类/超类）和Chicken类（子类）连接接起来；
在继承关系下，Chicken类将拥有Animal类所有的非私有的方法和属性，Chicken类还可以拥有自己独有的方法和属性；
声明Animal类，实例化Chicken类时， Chicken类会自动向上转型为Animal类；

举个栗子：

//创建动物类

public class Animal {
private String type;
private String skin;
private int legCount;
public void eat(){
System.out.println("动物正在吃东西");
}
public void breath(){
System.out.println("动物正在呼吸");
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getSkin() {
return skin;
}
public void setSkin(String skin) {
this.skin = skin;
}
public int getLegCount() {
return legCount;
}
public void setLegCount(int legCount) {
this.legCount = legCount;
}
}

//鸡类
public class Chicken extends Animal {
public void eat(){
System.out.println(“鸡正在吃东西”);
}
public void run(){
System.out.println(“鸡在跑");
}
}

//鸭类
public class Duck extends Animal {
public void eat(){
System.out.println(“鸭正在吃东西”);
}
 public void run(){
System.out.println(“鸭在跑");
}
}

//测试类

public class Test {
public static void main(String[] args){
Chicken chicken=new Chicken ();
chicken.eat();
chicken.setType(“鸡”);
chicken.setSkin(“金色");
chicken.setLegCount(2);
System.out.println("动物品种是： "+chicken.getType()+"， 肤色是： "+chicken.getSkin()+"， 腿数"+t.getLegCount());
chicken.run();
Duck duck =new Duck ();
duck.eat();
duck.fight();
}
}

Copier après la connexion

继承执行的顺序：

java中， new一个类的对象，类里面的静态代码块、非静态代码块、无参构造方法、有参构造方法、类的一般方法等部分，它们的执行顺序相对比较简单，例如：

public class FatherTest{
private String name;
public FatherTest(){
System.out.println(“--父类的无参数构造方法--”);
}
public FatherTest(String name){
System.out.println(“--父类的有参数构造方法--”+this.name);
}
static{
System.out.println(“--父类的静态代码块--”);
}
{
System.out.println(“--父类的非静态代码块--”);
}
public void speak(){
System.out.println(“--父类的方法--”);
}
}

public static void main(String[] args){
System.out.println(“--父类主程序--”);
FatherTest father = new FatherTest(“父亲的名字”);
father.speak();
}

执行结果为：
--父类的静态代码块--
--父类主程序--
--父类的非静态代码块--
--父类的有参构造函数--父亲的名字
--父类的方法--

执行顺序总结：
  静态代码块—>主程序—>非静态代码块—>构造函数—>一般方法

Copier après la connexion

加入子类继承后的执行顺序，例如：

public class SonTest extends FatherTest{
private String name;
static{
System.out.println("--子类的静态代码块--"); }
{
 System.out.println("--子类的非静态代码块--");
 }
public SonTest(){
System.out.println("--子类的无参构造方法--");
 }
public SonTest(String name){
System.out.println("--子类的有参构造方法--"+name);
 }
@Override
public void speak() { System.out.println("--子类重写了父类的方法--"); }
}


public static void main(String[] args) {
System.out.println("--子类主程序--");
FatherTest father=new FatherTest("父亲的名字");
father.speak();
SonTest son=new SonTest("儿子的名字");
son.speak();
}

执行结果为：
--父类的静态代码块--
--子类的静态代码块--
--子类主程序--
--父类的非静态代码块--
--父类的有参构造函数--父亲的名字
--父类的方法--
--父类的非静态代码块--
--父类的无参构造函数--
--子类的非静态代码块--
--子类的有参构造方法--儿子的名字
--子类重写了父类的方法--

Copier après la connexion

方法的重写：

方法重写是在继承关系下，子类拥有与父类方法名、参数(个数、顺序、类型)、返回值类型完全相同，访问修饰符只能扩大或相等，不可缩小，但实现过程与父类不同的方法。方法重写也是多态的一种变现形式。

重写必须满足以下几个条件：
在子类中可以根据需要对从基类中继承来的方法进行重写；
重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型；
重写方法不能使用比被重写的方法更严格的访问权限；

举个栗子：

//鸡类
class Chicken extends Animal {
public void eat(){
System.out.println(“鸡正在吃东西”);//对父类Animal中的eat方法进
行重写
}
 public void run(){
System.out.println(“鸡在跑");//可以添加新的方法
}
}

Copier après la connexion

Super关键字：

super关键字是一个特殊的变量，它提供了对父类的方法。可以用super主动调用父类的构造方法、访问父类中的成员。

super调用父类的构造方法：

public class Duck extends Animal {
public Duck(String name){
super(name);//主动调用父类的构造方法
}
}

Copier après la connexion

super访问父类的成员：

在子类方法中使用super访问父类中隐藏的成员，访问形式是：
super.变量；
super.方法名(参数);

public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println(super.name);//使用super调用父类的属性
eat();
super.eat();//使用super调用父类的eat()方法
}
public static void main(String[] args) {
new Duck().quack();//创建Duck类对象并调用quack方法
}
}

Copier après la connexion

final 关键字：

“final”关键字用来修饰类、方法和变量，其含义“不可改变的、最终的”。

修饰类 声明为final的类不能派生子类，即此类不能被继承；
public final class Person{ }
修饰变量 表示它为一个常量，变量一旦初始化，将不能改变；
final int COUNT = 5;
修饰方法 表示向编译器表明子类不能重写此方法；
public final void eat(){ }

Copier après la connexion

多态(polymorphism)

在面向对象语言中，多态性是指一个方法可以有多种实现版本，即“一种定义，多种实现”。利用多态可以设计和实现可扩展的系统，只要新类也在继承层次中。新的类对程序的通用部分只需进行很少的修改，或不做修改。类的多态性表现为方法的多态性，方法的多态性主要有方法的重载和方法的覆盖。

重载：

方法重载(overload)是指在同一个类中的多个方法可以同名但参数列表必须不同。重载表现为同一个类中方法的多态性。

class Chicken {
public void eat(){
System.out.println(“鸡正在吃东西”);
}
public void eat(String food){
System.out.println(“鸡在吃"+food);//重载eat方法
}
}

Copier après la connexion

方法重写(override)是指子类冲定义了父类中同名的方法。重写表现为父子与子类之间方法的多态性。

//鸡类
class Chicken extends Animal {
public void eat(){
System.out.println(“鸡正在吃东西”);//对父类Animal中的eat方法进
行重写
}
}

Copier après la connexion

对象类型转换：

基本类型的数据可以转换类型，当转换类型较高时可以自动转换，当转换类型较低时需要强制转换。对象类型也允许转换，这个转换只限于java类层次结构图上的一根枝干上，即父类和子类之间。枝干上离Object较近的为上，相反较远的为下，由此对象的类型转换分为“向上转型”和“向下转型”两种。

public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println("嘎嘎嘎");
}
public static void main(String[] args) {
Animal a1 = new Animal();//实例化过程
Animal a2 = new Duck();//向上转型
a1.eat();
a2.eat();
//a2.quack();//去除注释会怎样？
}
}

Copier après la connexion

向下转型：只能针对指向子类对象的基类对象引用进行。

public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println("嘎嘎嘎");
}
public static void main(String[] args) {
Animal a = new Duck();//向上转型
Duck b = (Duck) a;//向下转型
a.eat();
b.eat();
b.quack();
}
}

Copier après la connexion

Instanceof 关键字：

instanceof关键字是用来判断其左边对象是否为其右边的实例，返回boolean类型的数据 .

boolean result = Object instanceof class

Copier après la connexion

同时，也可以用来判断继承中的子类的实例是否为父类的实现。

.....
public static void main(String[] args) {
Animal a = new Duck();//向上转型
if(a instanceof Duck){
((Duck) a).quack();
}
}
.....

Copier après la connexion

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!