Quelles sont les trois principales caractéristiques de Java

Les trois principales caractéristiques de Java sont : 1. L'encapsulation, ce qui signifie cacher certaines informations d'une classe à l'intérieur de la classe et ne pas autoriser l'accès direct par des programmes externes. Au lieu de cela, les opérations et l'accès aux informations cachées sont réalisés via les méthodes fournies. par la classe. 2. L'héritage signifie que la sous-classe possède toutes les propriétés et méthodes de la classe parent, réalisant ainsi la réutilisation du code. 3. Le polymorphisme signifie que les références à la classe parent pointent vers des objets de sous-classe, produisant ainsi plusieurs formes.

L'environnement d'exploitation de ce tutoriel : système windows7, version java8, ordinateur DELL G3.

Trois fonctionnalités majeures de Java

Trois fonctionnalités majeures de l'orienté objet : encapsulation, héritage, polymorphisme.

Encapsulation :

• Cachez certaines informations de la classe à l'intérieur de la classe et n'autorisez pas l'accès direct par des programmes externes. Au lieu de cela, les opérations et l'accès aux informations cachées sont implémentés via les méthodes fournies par la classe.

Héritage :

• La sous-classe possède tous les attributs et méthodes de la classe parent (à l'exception des propriétés modifiées en privé), réalisant ainsi la réutilisation du code d'implémentation

Polymorphisme :

• Utilisation des références de classe parent Accepter, instances d'objet de différentes sous-classes, les références de classe parent appellent la même méthode et produisent des résultats différents selon les différentes instances de la sous-classe

1) Qu'est-ce que l'encapsulation

. Concept : masquez autant que possible les détails d'implémentation internes de l'objet et contrôlez les autorisations de modification et d'accès de l'objet.

Modificateur d'accès : privé (les attributs peuvent être modifiés comme privés, visibles uniquement par cette classe)

2) Méthodes d'accès publiques

utilisent la forme de méthodes d'accès pour effectuer des opérations d'affectation et d'acquisition de valeur.

Problème : La saisie illégale de données n'est toujours pas résolue ! Fournir des méthodes d'accès public pour garantir une saisie normale des données.

Convention de dénomination :

Assignment : setXXX() //Utiliser les paramètres de la méthode pour réaliser l'affectation

Valeur : getXXX() //Utiliser la valeur de retour de la méthode pour obtenir la valeur
• 3) Exemple

• public static void main(String[] args) {
  		int a;
  		Num num = new Num();
  //		传入值100
  		num.setNum(100);
  		System.out.println(num.getNum());
  	}

  private int a;
  
  //	在调用get方法时，返回本类a的值
  	public int getNum() {
  		return a;
  	}
  
  //	接受传入的值100，并赋值给本类的a
  	public void setNum(int num) {
  		this.a = num;
  	}

4) Filtrez les données valides

Dans la méthode d'accès public, ajoutez un jugement logique pour filtrer les données illégales afin de garantir la sécurité des données.

5) Résumé

La méthode get/set est le seul canal permettant au monde extérieur d'accéder aux propriétés privées de l'objet, et les données peuvent être détectées et filtrées à l'intérieur de la méthode.

2. L'héritage

1) L'héritage dans le programme

L'héritage dans le programme est un don ou une acquisition de caractéristiques et de comportements entre les classes. La relation d'héritage entre deux classes doit satisfaire la relation "est une".

2) Sélection de la classe parent

Dans la vraie vie, il existe des relations d'héritage entre de nombreuses catégories, qui satisfont toutes à la relation "est une".

Un chien est un animal, un chien est un être vivant et un chien est une substance.

• Plusieurs catégories peuvent être utilisées comme catégorie parent de « chien », et vous devez choisir parmi elles la catégorie parent la plus appropriée.

• Plus la fonction est raffinée, plus il y a de points qui se chevauchent et plus elle est proche de la classe parent directe.

• Plus la fonction est grossière, moins il y a de points qui se chevauchent et plus elle est proche de la classe Object. (Le concept selon lequel tout est un objet)

• 3) Héritage

Syntaxe : class subclass extends parent class { } //Lors de la définition d'une sous-classe, afficher l'héritage de la classe parent

public class 子类名 extends 父类名{
	
	//代码块
	}

Application : générer l'héritage Après la relation, la sous-classe peut utiliser les propriétés et les méthodes de la classe parent, ou définir des propriétés et des méthodes uniques à la sous-classe.

Avantages : Cela améliore non seulement la réutilisabilité du code, mais améliore également l'évolutivité du code.

4) Caractéristiques de l'héritage

Java est un héritage unique. Une classe ne peut avoir qu'une seule classe parent directe, mais elle peut avoir un héritage à plusieurs niveaux, et les attributs et méthodes peuvent être superposés étape par étape.

5) Non héritable

Méthode constructeur : La méthode constructeur dans une classe est uniquement responsable de la création des objets de cette classe et ne peut pas être héritée.

Propriétés et méthodes modifiées en privé : un type de modificateur d'accès, visible uniquement par cette classe. Lorsque les classes parent et enfant ne sont pas dans le même package, les attributs et méthodes modifiés par défaut : un type de modificateur d'accès, visible uniquement dans le même package.

3. Réécriture de méthode

1) Réécriture/remplacement de méthode

Principe de réécriture de méthode :

Le nom de la méthode et la liste des paramètres sont les mêmes que la classe parent. Le type de valeur de retour doit être le même que celui de la classe parent ou de sa sous-classe.

Le modificateur d'accès peut être le même que la classe parent ou plus large que la classe parent.

• Exécution de la réécriture de méthode :
• Après qu'une sous-classe ait réécrit une méthode de classe parent, la méthode réécrite de la sous-classe sera exécutée en premier lorsqu'elle est appelée.

Caractéristiques du remplacement de méthode :

• Lorsqu'une sous-classe remplace une méthode de classe parent, la méthode de sous-classe remplacera la méthode de classe parent.
  Lorsqu'une sous-classe remplace une méthode de classe parent, le niveau d'accès ne peut pas être plus strict que la méthode de classe parent.
• Le nom et le type de la méthode de remplacement de la sous-classe sont les mêmes que ceux de la classe parent.

  父类的构造方法无法重写，只能被覆盖。

示例:

//父类
public class Animal {
//	父类中吃的方法会输出“玩玩玩”
	public void play() {
		System.out.println("玩玩玩");
	}

//	父类中睡的方法会输出“睡睡睡”
	public void sleep() {
		System.out.println("睡睡睡");
	}

}

/**
 * 狗类继承 父类
 */
public class Dog extends Animal {

//	进行方法重写，将方法重写输出为“狗玩飞碟”
	public void play() {
		System.out.println("狗玩飞碟");
	}
}

public class Test {

	public static void main(String[] args) {
		// 实例化宠物对象
		Dog d = new Dog();
		d.play();
		d.sleep();
	}

}

运行输出:

2）方法重写与方法重载的区别

相同点:方法名相同
不同点:
重载:参数列表不同,返回值与访问修饰符无关
重写:参数列表相同,返回值相同或其子类,访问修饰符不能比父类更严

4、super关键字

1）super关键字

super关键字可在子类中访问父类的方法。

• 使用”super.”的形式访问父类的方法，进而完成在子类中的复用；
• 再叠加额外的功能代码，组成新的功能。

2）super调用父类无参构造

super()：表示调用父类无参构造方法。如果没有显示书写，隐式存在于子类构造方法的首行。

3）super调用父类有参构造

super()：表示调用父类无参构造方法。

super(实参)：表示调用父类有参构造方法。
参构造被执行

4）this与super

this或super使用在构造方法中时，都要求在首行。
当子类构造中使用了this()或this(实参)，即不可再同时书写super()或super(实参)，会由this()指向构造方法完成super()调用。

class A{
		public A(){
		System.out.println(( "A-无参构造"));
		}
		public A(int value) {
		System.out.println(("A-有参构造")); 
		}
		}
		class B extends A{
		public B(){
		super();
		System.out.println( "B-无参构造");
		}
		public B(int value) {
//		super();这两货不能跟同时存在
		this();
		System.out.println(("B-有参构造"));
		}
		}

5、多态

概念：父类引用指向子类对象，从而产生多种形态。

二者具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态。

父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。

1）多态的应用

方法重载可以解决接收不同对象参数的问题，但其缺点也比较明显。

• 首先，随着子类的增加，Master类需要继续提供大量的方法重载，多次修改并重新编译源文件。
• 其次，每一个feed方法与某一种具体类型形成了密不可分的关系，耦合太高。

场景一：使用父类作为方法形参实现多态，使方法参数的类型更为宽泛。

public class Animal {
//		父类中吃的方法会输出“玩玩玩”
	public void play() {
		System.out.println("玩玩玩");
	}

//	父类中睡的方法会输出“睡睡睡”
	public void sleep() {
		System.out.println("睡睡睡");
	}

}

/**
 * 狗类继承 父类
 * 
 * 
 *
 */
public class Dog extends Animal {

//	狗类特有的方法“狗吃狗粮”
	public void eat() {
		System.out.println("狗吃狗粮");
	}

}

public class Test {

	public static void main(String[] args) {
		// 实例化宠物对象
		Animal d = new Dog();
		d.play();
		d.sleep();
//		The method eat() is undefined for the type Animal
//		对于类型动物，eat()方法未定义
//		当我们去调用子类对象的特有方法时，就会爆出上面的错误提示
//		如果想要实现子类特有方法，就必须要强转
//		d.eat();
		((Dog) d).eat();
	}

}

运行输出:

场景二：使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。

示例:

//动物类  父类
public class Animal {
	public void food() {
		System.out.println("...");
	}
}

//用extends关键字,继承父类属性
public class Dog extends Animal {

	public void food() {
		System.out.println("狗吃狗粮");
	}

	public void runing() {
		System.out.println("一直跑跑跳跳");
	}
}

//用extends关键字,继承父类属性
public class Fish extends Animal {
	public void food() {
		System.out.println("大鱼吃小鱼,小鱼吃虾米");
	}

	public void swimming() {
		System.out.println("小鱼儿,一直游");
	}
}

public class Master {
//	传入你的动物，并去给它喂食
	public void food(Animal animal) {
		System.out.println("喂食");
		animal.food();
	}
}

import java.util.Scanner;

public class Shopping {
//	你没有动物，所以animal为空
	Animal animal = null;

//	判断你要购买的宠物，并返回宠物类（狗、鱼）
	public Animal shopping(int a) {
		if (a == 1) {
			animal = new Dog();
		} else if (a == 2) {
			animal = new Fish();
		}
//		this.animal=animal;
		return animal;
	}

	public void showMenu() {
		Scanner input = new Scanner(System.in);
		System.out.println("欢迎来到一只宠物宠物店");
		System.out.println("请选择喜欢的宠物:");
		System.out.println("1.狗 2.鱼 ");
		int a = input.nextInt();
		Animal animal = shopping(a);
		Master mm = new Master();
		mm.food(animal);
//		用instanceof判断你买的是狗还是鱼。
//		狗就执行狗的属性和方法，鱼就执行鱼的属性和方法
		if (animal instanceof Dog) {
			Dog d = (Dog) animal;
			d.runing();
		} else if (animal instanceof Fish) {
			Fish f = (Fish) animal;
			f.swimming();
		}

	}
}

//测试类
public class text {
	public static void main(String[] args) {
		Shopping shop = new Shopping();
		shop.showMenu();
	}
}

运行结果:

2）多态的静态和动态实现

动态绑定：即为重写/覆盖，方法的重写

动态绑定也叫后期绑定，在运行时，虚拟机根据具体对象实例的类型进行绑定，或者说是只有对象在虚拟机中运行创建了之后，才能确定方法属于哪一个对象实例的

• 根据实际对象是什么，就去找相应对象方法去执行。
• 动态绑定是在运行时才会执行（例如重写的方法）。

静态绑定：即为重载，方法的重载

一个方法的参数在编译阶段常被静态地绑定,它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数

• 根据类型找相应的属性或者静态变量。
• 静态绑定是在编译时执行（如成员变量，静态方法）。

更多编程相关知识，请访问：编程教学！！

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!