Instanciation de classe
Code
Écrivez une classe Student, y compris le nom, le sexe, l'âge, l'ID, les attributs de score, qui sont String, String, int, int et double.
Une méthode say est déclarée dans la classe, qui retourne le type String, et les informations de retour de la méthode contiennent toutes les valeurs d'attribut.
Dans la méthode principale d'une autre classe StudentTest, créez un objet Student, accédez à la méthode say et à tous les attributs, et imprimez le résultat de l'appel.
répondre:
class Student {
private String name;
private String gender;
private int age;
private int id;
private double score;
public Student(String name, String gender, int age, int id, double score) {
this.name = name;
this.gender = gender;
this.age = age;
this.id = id;
this.score = score;
}
public String say(){
return "名字：" + name + "; 性别："+ gender + "; 年龄"+ age + "; id:" + id + ";成绩："+score;
}
}
public class StudentTest {
public static void main(String[] args) {
Student s=new Student("素媛","女",22,520,100);
System.out.println(s.say());
}
}Problème de programmation 1
Définissez une classe Mari avec les attributs de nom, d'âge et d'épouse;
Définissez une classe d'épouse, avec les attributs de nom, d'âge et de mari;
Il existe une méthode getInfo dans la classe mari, qui peut afficher son nom, son âge, ainsi que le nom et l'âge de sa femme;
Il existe une méthode getInfo dans la classe wife, qui peut afficher votre nom, votre âge, le nom et l'âge de son mari;
Définissez une classe de test, créez des objets épouse et mari, puis testez.
répondre:
class Husband{
public String name;
public int age;
public Wife wife;
public Husband(String name, int age) {
this.name = name;
this.age = age;
}
public void getinfo(){
System.out.println("我是丈夫："+name +" 年龄："+age+" 妻子："+wife.name+" 年龄："+wife.age);
}
}
class Wife{
public String name;
public int age;
public Husband husband;
public Wife(String name, int age) {
this.name = name;
this.age = age;
}
public void getinfo(){
System.out.println("我是妻子："+name +" 年龄："+age+" 丈夫："+husband.name+" 年龄："+husband.age);
}
}
public class TestOfLove {
public static void main(String[] args) {
Husband hb=new Husband("健哥",18);
Wife wf=new Wife("媛姐",19);
hb.wife=wf;
wf.husband=hb;
hb.getinfo();
wf.getinfo();
}
}résultat de l'opération:
我是丈夫：健哥 年龄：18 妻子：媛姐 年龄：19
我是妻子：媛姐 年龄：19 丈夫：健哥 年龄：18
Question de programmation 2
Définissez la classe de compte bancaire Compte, qui a des attributs: numéro de carte cid, solde du solde et appartient à l'utilisateur Client
Le compte bancaire a des méthodes:
(1) getInfo (), retourne le type de chaîne, retourne les détails de la carte
(2) Méthode Withdraw (), les paramètres sont auto-conçus, si le retrait est réussi, il retourne true, et s'il échoue, il retourne false
(3) La méthode save () pour économiser de l'argent, les paramètres sont conçus par vous-même, si la sauvegarde est réussie, elle retourne true, et si elle échoue, elle retourne false
La catégorie Client a des attributs tels que le nom, le numéro d'identification, le numéro de contact et l'adresse du domicile
La classe Customer a une méthode say (), qui renvoie un type String et renvoie ses informations personnelles.
Créez un objet de classe de compte bancaire et un objet de classe d'utilisateurs dans la banque de test, définissez les informations et affichez les informations
Analyse: Semblable à l'idée et à l'écriture de la question précédente, vous pouvez l'ignorer ici.
Utilisation de la méthode
Quelle option et méthode show () sont surchargées
Démo de classe {
void show (int a, int b, float c) {}
}
A.void show (int a, float c, int b) {} // oui
B, void show (int a, int b, float c) {} // Exactement pareil. Ne peut pas apparaître dans la même classe.
C.int show (int a, float c, int b) {return a;} // oui。
D.int show (int a, float c) {return a;} // oui
Réponse: ACD
Déclaration et appel de méthode
(1) Déclarer un type de cylindre,
(2) Déclarer les attributs: le rayon et la hauteur du bord inférieur
(3) Méthode de déclaration:
A: La fonction de la méthode: imprimer les informations détaillées du cylindre dans la méthode
Le rayon du côté inférieur du cylindre est xxx, la hauteur est xxx, la zone inférieure est xxx et le volume est xxx.
B: La fonction de la méthode: retourne la zone du bas
C: Fonction de la méthode: volume de retour
D: La fonction de la méthode: attribuer une valeur au rayon de la face inférieure du cylindre et à la hauteur
E: La fonction de la méthode: Attribuer une valeur au rayon et à la hauteur du bas du cylindre, et renvoyer le résultat de l'affectation
Si le rayon ou la hauteur du bord inférieur est <= 0, l'affectation échoue et renvoie false, sinon elle renvoie true
(4) et tester
répondre:
class Cylinder{
double radius;//底边半径
double height;//高
/*
A：方法的功能：在方法中打印圆柱体的详细信息
圆柱体的底边的半径是xxx，高是xxx，底面积是xxx，体积是xxx。
*/
void printDetails(){
//double area = Math.PI * radius * radius;//底面积
//double volume = area * height;//体积
//System.out.println("圆柱体的底边的半径是" + radius +" ，高是" + height + "，底面积是"+ area +"，体积是"+volume +"。");
//调用本类的方法
System.out.println("圆柱体的底边的半径是" + radius +" ，高是" + height + "，底面积是"+ getArea() +"，体积是"+getVolume() +"。");
}
//B：方法的功能：返回底面积
double getArea(){
double area = Math.PI * radius * radius;//底面积
return area;
}
//C：方法的功能：返回体积
double getVolume(){
//double area = Math.PI * radius * radius;//底面积
//double volume = area * height;//体积
//return volume;
double volume = getArea() * height;//体积
return volume;
}
//D：方法的功能：为圆柱体的底边的半径，和高赋值
void setValue(double r, double h){
radius = r;
height = h;
}
/*
E：方法的功能：为圆柱体的底边的半径，和高赋值，并返回赋值的结果
如果底边的半径或高为<=0，赋值失败，返回false，否则返回true
*/
boolean setRadiusAndHeight(double r, double h){
if(r<=0 || h<=0){
return false;
}
//radius = r;
//height = h;
setValue(r,h);
return true;
}
}
class TestMethodExer{
public static void main(String[] args){
//1、创建对象
Cylinder c = new Cylinder();
//c.radius = 2.0;
//c.height = 2;
c.setValue(2.0,2);
c.printDetails();
System.out.println("底面积： " + c.getArea());
System.out.println("体积： " + c.getVolume());
boolean flag = c.setRadiusAndHeight(3.0, 5);
if(!flag){// 如果flag = false, !flag结果就是true,条件成立
System.out.println("赋值失败");
}else{
c.printDetails();
}
}
}
résultat de l'opération:
圆柱体的底边的半径是2.0 ，高是2.0，底面积是12.566370614359172，体积是25.132741228718345。
底面积： 12.566370614359172
体积： 25.132741228718345
圆柱体的底边的半径是3.0 ，高是5.0，底面积是28.274333882308138，体积是141.3716694115407。Surcharge de méthode
La surcharge de méthode (surcharge) doit satisfaire ________
A. Méthodes définies dans différentes classes B. Méthodes définies dans le même type
C. Le nom de la méthode doit être le même D. Le type de retour doit être le même
E. Les paramètres doivent être différents F. Les paramètres peuvent être les mêmes
Réponse: BCE
Écrire la sortie
class Demo{
public static void main(String[] args){
show(0);
show(1);
}
public static void show(int i){
switch(i){
default:
i+=2;
case 1:
i+=1;
case 4:
i+=8;
case 2:
i+=4;
}
System.out.println("i="+i);
}
}répondre:
i=15
i=14
Écrire la sortie
class Demo{
public static void main(String[] args){
int x = 1;
for(show('a'); show('b') && x<3; show('c')){
show('d');
x++;
}
}
public static boolean show(char ch){
System.out.print(ch);
return true;
}
}abdcbdcbÉcrire la sortie
public class Test1 {
public static boolean foo(char c) {
System.out.print(c);
return true;
}
public static void main(String[] args) {
int i = 0;
for (foo('A'); foo('B') && (i < 2); foo('C')) {
i++;// 1 2
foo('D');
}
}
}ABDCBDCBOrienté objet
Description des trois caractéristiques de l'orientation objet
答：面向对象有三大特点：封装、继承、多态。(如果要回答四个，可加上 抽象性 这一特点)
1.继承性：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
2.封装性：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
3. 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
4.抽象性：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。Portée publique, privée, protégée et la différence lorsqu'elle n'est pas écrite par défaut
Trouver mal
public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
有错吗?答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。Garbage collection de la gestion de la mémoire Java (comprendre)
分配：由JVM自动为其分配相应的内存空间
释放：由JVM提供垃圾回收机制自动的释放内存空间
垃圾回收机制（GC：Garbage Collection）：将垃圾对象所占用的堆内存进行回收。Java的垃圾回收机制是JVM提供的能力，由单独的系统级垃圾回收线程在空闲时间以不定时的方式动态回收。
垃圾对象：不再被任何引用指向的对象。Questions d'entretien:
Question: Le mécanisme de récupération de place peut-il être notifié pour collecter les déchets dans le programme?
能，通过调用System.gc();或Runtime.getRuntime().gc();Demandez à nouveau: après avoir appelé System.gc (); ou Runtime.getRuntime (). Gc () ;, le garbage collection est-il effectué immédiatement?
不是，该调用并不会立刻启动垃圾回收机制开始回收，但会加快垃圾回收机制的运行。public class TestGC{
public static void main(String[] args)throws Exception{
for(int i=0; i<10; i++){
MyClass m = new MyClass();//这里本次循环完，本次创建的对象就成为垃圾了
System.out.println("创建第" + (i+1) + "的对象：" + m);
}
//通知垃圾回收机制来收集垃圾
System.gc();
//为了延缓程序结束
for(int i=0; i<10; i++){
Thread.sleep(1);
System.out.println("程序在继续....");
}
}
}
class MyClass{
//这个方法是垃圾回收机制在回收它的对象时，自动调用，理解成对象留临终遗言的方法
public void finalize(){
System.out.println("轻轻的我走了.....");
}
}Constructeur
Constructor peut-il être remplacé?
答：构造器Constructor不能被继承，因此不能重写Override，但可以被重载OverloadCréez une classe Box par programme, définissez-y trois variables pour représenter la longueur, la largeur et la hauteur d'un cube et définissez une méthode pour trouver le volume du cube. Créez un objet et trouvez le volume d'un cube d'une taille donnée.
(Fournissez un constructeur sans paramètre et un constructeur paramétré)
pass
Définir un type de cercle
Fournir une méthode pour afficher la circonférence de la circonférence
Fournir une méthode pour afficher l'aire d'un cercle
Fournir un constructeur sans paramètre et un constructeur paramétré
pass
Concevez une classe Dog avec des attributs de nom, de couleur et d'âge, définissez le constructeur pour initialiser ces attributs et définissez la méthode de sortie show () pour afficher ses informations.
Fournir un constructeur sans paramètre et un constructeur paramétré
pass
Définir une classe pour décrire les points de coordonnées
(1) Il a pour fonction de calculer la distance entre le point actuel et l'origine
(2) Trouvez la distance à n'importe quel point (m, n)
(3) Trouvez la distance à n'importe quel point (Point p)
(4) Avec la fonction d'affichage du point de coordonnées, format d'affichage (x, y)
(5) Fournir un constructeur sans paramètres et un constructeur avec des paramètres
répondre:
public class Point {
public int X;
public int Y;
public Point() {
}
public Point(int x, int y) {
X = x;
Y = y;
}
public double OXY(){
return Math.sqrt(X*X+Y*Y);
}
public double AnyXY(int x,int y){
return Math.sqrt((X-x)*(X-x)+(Y-y)*(Y-y));
}
public double PXY(Point P){
return Math.sqrt((P.X-X)*(P.X-X)+(P.Y-Y)*(P.Y-Y));
}
public static void main(String[] args) {
Point P=new Point(1,1);
Point P1=new Point(3,3);
System.out.println("P与原点的距离："+P.OXY());
System.out.println("P到(2,2)的距离"+P.AnyXY(2,2));
System.out.println("P到P1的距离"+P.PXY(P1));
}
}résultat de l'opération:
P与原点的距离：1.4142135623730951
P到(2,2)的距离1.4142135623730951
P到P1的距离2.8284271247461903Ecrire une classe humaine
Attributs: nom, sexe, âge; fournir un constructeur sans paramètres et un constructeur avec des paramètres
Méthodes: (1) Méthode d'auto-introduction (2) Méthode d'alimentation
Créer un objet "Zhang San"
passÉcrivez une classe de voiture:
Attributs: marque; capitaine; couleur; prix;
Créez cinq objets: "Jetta", "BMW", "Rolls Royce", "Cruz", "Mai Rui Bao"
Fournir un constructeur sans paramètre et un constructeur paramétré
passRédigez un cours:
Attributs: nom du cours, heures de cours, professeur de classe;
Créez cinq objets: "langage c", "programmation java", "programmation réseau php", "c ++", "structure de données"
Fournir un constructeur sans paramètre et un constructeur paramétré
pass
Le résultat du programme suivant est:
public class Test1 {
public static void main(String[] args) {
new A(new B());
}
}
class A{
public A(){
System.out.println("A");
}
public A(B b){
this();
System.out.println("AB");
}
}
class B{
public B(){
System.out.println("B");
}
}答案：
B
A
ABÀ propos du passage de paramètres
Exercice un
Écrivez le résultat.
public class Test{
public static void leftshift(int i, int j){
i+=j;
}
public static void main(String args[]){
int i = 4, j = 2;
leftshift(i, j);
System.out.println(i);
}
}答案：4 形参Exercice deux
Écrivez le résultat.
public class Demo{
public static void main(String[] args){
int[] a=new int[1];
modify(a);
System.out.println(a[0]); //
}
public static void modify(int[] a){
a[0]++;
}
} 答案： 1 实参Exercice trois
Écrivez le résultat.
public class TestA {
int i ;
void change(int i){
i++;
System.out.println(i);
}
void change1(TestA t){
t.i++;
System.out.println(t.i);
}
public static void main(String[] args) {
TestA ta = new TestA();
System.out.println(ta.i); //
ta.change(ta.i);//
System.out.println(ta.i); //
ta.change1(ta); //
System.out.println(ta.i);//
}
}答案：
0
1
0
1
1Exercice quatre
Ecrire le résultat
class Value{
int i = 15;
}
class Test{
public static void main(String argv[]) {
Test t = new Test();
t.first();
}
public void first() {
int i = 5;
Value v = new Value();
v.i = 25;
second(v, i);
System.out.println(v.i);
}
public void second(Value v, int i) {
i = 0;
v.i = 20;
Value val = new Value();
v = val;
System.out.print(v.i + " " + i);
}
}
A.15 0 20
B.15 0 15
C.20 0 20
D.0 15 20答案：A
v = val;//局部形参v的引用指向原来传入的v，改为指向val,原来传入的v不变Exercice cinq
1. public class Test {
2. int x= 12;
3. public void method(int x) {
4. x+=x;
5. System.out.println(x);
6. }
7. }
Given:
34. Test t = new Test();
35. t.method(5);
What is the output from line 5 of the Test class?
A. 5
B. 10
C. 12
D. 17
E. 24答案： B
优先使用局部变量的XExercice six
import java.util.Arrays;
public class PassValueExer2{
public static void main(String[] args){
int[] array = {3,2,5,1,7};
//调用sort方法，实现从大到小排序
//在此处补充代码
....
//显示结果
System.out.println("排序后的结果是：" + Arrays.toString(array));
}
//要求使用冒泡排序完成
public void sort(//形参？){
}
}répondre:
import java.util.Arrays;
public class PassValueExer2{
public static void main(String[] args){
int[] array = {3,2,5,1,7};
//调用sort方法，实现从大到小排序
//在此处补充代码
PassValueExer2.sort(array);
//显示结果
System.out.println("排序后的结果是：" + Arrays.toString(array));
}
//要求使用冒泡排序完成
public static void sort(int[] a){
int pos=0;
int i=a.length-1;
while(i>0){
for (int j=0;j<i;j++){
if (a[j]<a[j+1]){
int t=a[j];
a[j]=a[j+1];
a[j+1]=t;
pos=j;
}
}
i=pos;
}
}
}排序后的结果是：[7, 5, 3, 2, 1]Quel est le résultat d'exécution du code suivant
public class PassValueExer2{
public static void main(String[] args) {
int i = 0;
change(i);
i = i++;
System.out.println("i = " + i);
}
public static void change(int i){
i++;
}
}答案：0
典型的i=i++的问题 ，可上网查阅资料，我理解的是右边的i先赋值给左边的i，然后右边的i再自加存到隐身临时变量里，自加后的值并没有作用于左边的i，所以左边的i为右边初始的i。Les résultats du programme suivant:
public static void main(String[] args) {
String str = new String("world");
char[] ch = new char[]{'h','e','l','l','o'};
change(str,ch);
System.out.println(str);
System.out.println(String.valueOf(ch));
}
public static void change(String str, char[] arr){
str = "change";
arr[0] = 'a';
arr[1] = 'b';
arr[2] = 'c';
arr[3] = 'd';
arr[4] = 'e';
}répondre:
world
abcdeQuel est le résultat du code suivant?
public class Test {
int a;
int b;
public void f(){
a = 0;
b = 0;
int[] c = {0};
g(b,c);
System.out.println(a + " " + b + " " + c[0]);
}
public void g(int b, int[] c){//a1 b0 c1
a = 1;
b = 1;
c[0] = 1;
}
public static void main(String[] args) {
Test t = new Test();
t.f();
}
}1 0 1Réponse courte
Lorsqu'un objet est passé en paramètre à une méthode, la méthode peut modifier les propriétés de l'objet et renvoyer le résultat modifié. Est-il donc passé par valeur ou par référence?
答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的Complétez le code dans la fonction de comparaison et n'ajoutez pas d'autres fonctions.
class Circle {
private double radius;
public Circle(double r) {
radius = r;
}
public Circle compare(Circle cir) {
// 程序代码
/*
* if(this.radius>cir.radius) return this; return cir;
*/
// return (this.radius>cir.radius)?this: cir;
}
}
class TC {
public static void main(String[] args) {
Circle cir1 = new Circle(1.0);
Circle cir2 = new Circle(2.0);
Circle cir;
cir = cir1.compare(cir2);
if (cir1 == cir)
System.out.println("圆1的半径比较大");
else
System.out.println("圆2的半径比较大");
}
}répondre:
class Circle {
private double radius;
public Circle(double r) {
radius = r;
}
public Circle compare(Circle cir) {
// 程序代码
/*
* if(this.radius>cir.radius) return this; return cir;
*/
// return (this.radius>cir.radius)?this: cir;
return this.radius >cir.radius ? this : cir;
}
}
public class TC {
public static void main(String[] args) {
Circle cir1 = new Circle(1.0);
Circle cir2 = new Circle(2.0);
Circle cir;
cir = cir1.compare(cir2);
if (cir1 == cir)
System.out.println("圆1的半径比较大");
else
System.out.println("圆2的半径比较大");
}
}