【Java基础】· 面向对象编程(上)习题详解

写在前面


        Hello大家好, 我是【麟-小白】,一位软件工程专业的学生,喜好计算机知识。希望大家能够一起学习进步呀!本人是一名在读大学生,专业水平有限,如发现错误不足之处,请多多指正!谢谢大家!!!

        如果小哥哥小姐姐们对我的文章感兴趣,请不要吝啬你们的小手,多多点赞加关注呀!❤❤❤ 爱你们!!!


目录

写在前面

【面向对象编程(上)知识详解】

类的实例化

代码实现

编程题1

编程题2

方法的使用

方法的声明与调用

方法的重载

写出输出结果

写出输出结果

以下代码的运行结果是什么?

面向对象性

面向对象三大特征的说明

作用域public,private,protected,以及默认不写时的区别

找错

Java的内存管理之垃圾回收(了解)

面试题:

构造器

构造器Constructor是否可被override

编程创建一个Box类,在其中定义三个变量表示一个立方体的长、宽和高,定义一个方法求立方体的体积。创建一个对象,求给定尺寸的立方体的体积。(提供无参的构造器和一个有参的构造器)

定义一个圆类型

设计一个Dog类,有名字、颜色和年龄属性,定义构造器初始化这些属性,定义输出方法show()显示其信息。

写一个人的类

写一个汽车类:

以下程序的运行结果是:

关于参数传递

练习一

练习二

练习三

练习四

练习五

以下代码的执行结果是什么

简答

结语


【面向对象编程(上)知识详解】

一文带你深入理解【Java基础】· 面向对象编程(上)①

一文带你深入理解【Java基础】· 面向对象编程(上)②


类的实例化

代码实现

编写一个Student类,包含name、gender、age、id、score属性,分别为String、String、int、int、double类型。

类中声明一个say方法,返回String类型,方法返回信息中包含所有属性值。

在另一个StudentTest类中的main方法中,创建Student对象,并访问say方法和所有属性,并将调用结果打印输出。

/*
 * 代码实现
编写一个Student类,包含name、gender、age、id、score属性,分别为String、String、int、int、double类型。
类中声明一个say方法,返回String类型,方法返回信息中包含所有属性值。
在另一个StudentTest类中的main方法中,创建Student对象,并访问say方法和所有属性,并将调用结果打印输出。
 */

public class StudentTest {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "Tom";
		stu.age = 10;
		stu.gender = "man";
		stu.score = 65.5;
		stu.id = 123456;
		String info = stu.say();
		System.out.println(info);
	}
}

public class Student {
	String name;
	String gender;
	int age;
	int id;
	double score;
	
	public String say(){
		return "姓名是:" + name + ", 性别是:" + gender + ", 年龄是:" 
				+ age + ", id是:" + id + "分数是:" + score;
	}
}


编程题1

定义一个丈夫Husband类,有姓名、年龄、妻子属性

定义一个妻子Wife类,有姓名、年龄、丈夫属性

丈夫类中有一个getInfo方法,其中,能显示自己的姓名,年龄,和他的妻子的姓名,年龄

妻子类中有一个getInfo方法,其中,能显示自己的姓名,年龄,和她的丈夫的姓名,年龄

定义一个测试类,创建妻子和丈夫对象,然后测试

/*
 * 
 * 编程题1
定义一个丈夫Husband类,有姓名、年龄、妻子属性
定义一个妻子Wife类,有姓名、年龄、丈夫属性
丈夫类中有一个getInfo方法,其中,能显示自己的姓名,年龄,和他的妻子的姓名,年龄
妻子类中有一个getInfo方法,其中,能显示自己的姓名,年龄,和她的丈夫的姓名,年龄
定义一个测试类,创建妻子和丈夫对象,然后测试
 */
public class Test {
	public static void main(String[] args) {
		Husband husband = new Husband("Tom", 22);
		Wife wife = new Wife("Susan", 20);
		husband.setWife(wife);
		wife.setHusband(husband);
		System.out.println(husband.getInfo());
		System.out.println(wife.getInfo());
	}
}

public class Husband {
	private String name;
	private int age;
	private Wife wife;

	public Husband(String name, int age) {
		this.name = name;
		this.age = age;
	}

	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 setWife(Wife wife) {
		this.wife = wife;
	}

	public Wife getWife() {
		return wife;
	}

	public String getInfo() {
		return "丈夫叫:" + name + "年龄是:" + age + "妻子叫:" + wife.getName() + "年龄是:" + wife.getAge();
	}
}

public class Wife {
	private String name;
	private int age;
	private Husband husband;

	public Wife(String name, int age) {
		this.name = name;
		this.age = age;
	}

	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 setHusband(Husband husband) {
		this.husband = husband;
	}

	public Husband getHusband() {
		return husband;
	}

	public String getInfo() {
		return "妻子叫:" + name + "年龄是:" + age + "丈夫叫:" + husband.getName() + "年龄是:" + husband.getAge();
	}
}


编程2

定义银行账户类Account,有属性:卡号cid,余额balance,所属用户Customer   

银行账户类Account有方法:

(1)getInfo(),返回String类型,返回卡的详细信息

(2)取钱方法withdraw(),参数自行设计,如果取钱成功返回true,失败返回false

(3)存钱方法save(),参数自行设计,如果存钱成功返回true,失败返回false

其中Customer类有姓名、身份证号、联系电话、家庭地址等属性Customer类有方法say(),返回String类型,返回他的个人信息。

在测试类Bank中创建银行账户类对象和用户类对象,并设置信息,与显示信息。

/*
 * 定义银行账户类Account,有属性:卡号cid,余额balance,所属用户Customer   
银行账户类Account有方法:
(1)getInfo(),返回String类型,返回卡的详细信息
(2)取钱方法withdraw(),参数自行设计,如果取钱成功返回true,失败返回false
(3)存钱方法save(),参数自行设计,如果存钱成功返回true,失败返回false
   
其中Customer类有姓名、身份证号、联系电话、家庭地址等属性
    Customer类有方法say(),返回String类型,返回他的个人信息。

在测试类Bank中创建银行账户类对象和用户类对象,并设置信息,与显示信息
 */

public class Bank {
	public static void main(String[] args) {
		Customer c = new Customer("Tom", 1001, 123456789, "地球");
		Account a = new Account(123456, 1000, c);
		System.out.println(c.say());
		System.out.println(a.getInfo());
		System.out.println(a.save(1000));
		System.out.println(a.getInfo());
		System.out.println(a.withdraw(300));
		System.out.println(a.getInfo());
	}
}

public class Account {
	private long cid;
	private int balance;
	private Customer customer;
	
	public long getCid() {
		return cid;
	}

	public void setCid(long cid) {
		this.cid = cid;
	}

	public int getBalance() {
		return balance;
	}

	public void setBalance(int balance) {
		this.balance = balance;
	}

	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

	public String getInfo(){
		return "卡号是:" + cid + "\n" + "余额是:" + balance;
	}

	public Account(long cid, int balance, Customer customer) {
		super();
		this.cid = cid;
		this.balance = balance;
		this.customer = customer;
	}

	public boolean withdraw(int m){
		if(m>=balance){
			return false;
		}else{
			balance -= m;
			return true;
		}
	}
	
	public boolean save(int m){
		if(m<=0){
			return false;
		}else{
			balance += m;
			return true;
		}
	}
}

public class Customer {
	private String name;
	private long id;
	private long phone;
	private String address;
	
	public Customer(String name, long id, long phone, String address) {
		this.name = name;
		this.id = id;
		this.phone = phone;
		this.address = address;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public long getPhone() {
		return phone;
	}

	public void setPhone(long phone) {
		this.phone = phone;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String say(){
		return "姓名:" + name +  "\n" + "身份证号:" + id + "\n" + 
				"电话号码:" + phone + "\n" + "地址:" + address;
	}
}


方法的使用

哪个选项和show()方法重载
class Demo{
    void show(int a,int b,float c){}
}

A.void show(int a,float c,int b){}//yes

B,void show(int a,int b,float c){}//一模一样。不可以出现在同一个类中。

C.int show(int a,float c,int b){return a;}//yes。

D.int show(int a,float c){return a;}//yes


方法的声明调用

(1)声明一个圆柱体类型,

(2)声明属性:底边的半径,和高

(3)声明方法:

A:方法的功能:在方法中打印圆柱体的详细信息

圆柱体的底边的半径是xxx,高是xxx,底面积是xxx,体积是xxx。

B:方法的功能:返回底面积

C:方法的功能:返回体积

D:方法的功能:为圆柱体的底边的半径,和高赋值

E:方法的功能:为圆柱体的底边的半径,和高赋值,并返回赋值的结果

如果底边的半径或高为<=0,赋值失败,返回false,否则返回true

(4)并测试

//声明圆柱体
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();
		}
	}
}


方法的重载

方法重载(overload)必须满足________

A. 在不同class中定义的方法     B.在同一类型中定义的方法

C. 方法名必须相同              D.返回类型必须相同

E. 参数一定不同                F.参数可以相同

答案:BCE


写出输出结果

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);
    }
}

答案:i=15

           i=14


写出输出结果

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


以下代码的运行结果是什么?

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');
		}
	}
}

答案:ABDCBDCB


面向对象性

面向对象三大特征的说明

答:面向对象有三大特点:封装、继承、多态。(如果要回答四个,可加上 抽象性 这一特点)

1.继承性:

继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量,并且类可以修改或增加新的方法使之更适合特殊的需要。

2.封装性:

封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。

3. 多态性:

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。

4.抽象性:

抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数据抽象。


作用域public,private,protected,以及默认不写时的区别

java中常用的访问限制修饰符有public,private,protected,以及不写,不写的修饰符也叫缺省的修饰符或者友好的修饰符。

1.private修饰的成员变量和函数只能在类本身和内部类中被访问。

2.protected 修饰的成员变量和函数能被类本身、子类及同一个包中的类访问。

3.public修饰的成员变量和函数可以被类、子类、同一个包中的类以及任意其他类访问。

4.默认情况(不写)下,属于一种包访问,即能被类本身以及同一个包中的类访问。


找错

public class Something {
   void doSomething () {
       private String s = "";
       int l = s.length();
   }
}

有错吗?

答案: 错。局部变量前不能放置任何访问修饰符 (private,public,和protected)。


Java的内存管理之垃圾回收(了解)

分配:由JVM自动为其分配相应的内存空间

释放:由JVM提供垃圾回收机制自动的释放内存空间

垃圾回收机制(GC:Garbage Collection):将垃圾对象所占用的堆内存进行回收。Java的垃圾回收机制是JVM提供的能力,由单独的系统级垃圾回收线程在空闲时间以不定时的方式动态回收。

垃圾对象:不再被任何引用指向的对象。


面试题:

问:在程序中是否可以通知垃圾回收机制过来回收垃圾?

能,通过调用System.gc();或Runtime.getRuntime().gc();

再问:调用了System.gc();或Runtime.getRuntime().gc();后是立刻执行垃圾回收吗?

不是,该调用并不会立刻启动垃圾回收机制开始回收,但会加快垃圾回收机制的运行。

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("轻轻的我走了.....");
	}
}


构造器

构造器Constructor是否可被override

答:构造器Constructor不能被继承,因此不能重写Override,但可以被重载Overload


编程创建一个Box类,在其中定义三个变量表示一个立方体的长、宽和高,定义一个方法求立方体的体积。创建一个对象,求给定尺寸的立方体的体积。(提供无参的构造器和一个有参的构造器)

public class Box {
	private int length;
	private int width;
	private int height;

	public Box() {
		super();
	}

	public Box(int length, int width, int height) {
		super();
		this.length = length;
		this.width = width;
		this.height = height;
	}

	public int getarea() {
		return length * width * height;
	}
}


定义一个圆类型

提供显示圆周长功能的方法

提供显示圆面积的方法

提供无参的构造器和一个有参的构造器

public class Circle {
	private int r;

	public Circle() {
		super();
	}

	public Circle(int r) {
		super();
		this.r = r;
	}

	public void getCircumferent() {
		System.out.println("圆的周长为:" + 2 * Math.PI * r);
	}

	public void getArea() {
		System.out.println("圆的面积为:" + Math.PI * r * r);
	}
}


设计一个Dog类,有名字、颜色和年龄属性,定义构造器初始化这些属性,定义输出方法show()显示其信息。

提供无参的构造器和一个有参的构造器

public class Dog {
	String name;
	String color;
	int age;

	public Dog() {
		super();
	}

	public Dog(String name, String color, int age) {
		super();
		this.name = name;
		this.color = color;
		this.age = age;
	}

	public void show() {
		System.out.println("狗狗的名字为:" + name + "狗狗的颜色为:" + color + "狗狗的年龄为:" + age);
	}
}


写一个人的类

属性:名字,性别,年龄;提供无参的构造器和一个有参的构造器

方法:(1)自我介绍的方法(2)吃饭的方法

创建一个对象“张三”

public class Person {
	private String name;
	private char gender;
	private int age;

	public Person() {
		super();
	}

	public Person(String name) {
		super();
		this.name = name;
	}

	public void selfIntroduction(String name, char gender, int age) {
		System.out.println("我叫:" + name + ",性别:" + gender + ",年龄:" + age);
	}

	public void eat() {
		System.out.println("人吃饭");
	}

	public static void main(String[] args) {
		Person person = new Person("张三");
		person.selfIntroduction("张三", '男', 20);
	}
}


写一个汽车类:

属性:品牌;车长;颜色;价格;

创建五个对象:“捷达”,“宝马”,“劳斯莱斯”,“科鲁兹”,“迈锐宝”

提供无参的构造器和一个有参的构造器

public class Car {
	private String brand;
	private int length;
	private String color;
	private int price;

	public Car() {
		super();
	}

	public Car(String brand) {
		super();
		this.brand = brand;
	}

	public static void main(String[] args) {
		Car car1 = new Car("捷达");
		Car car2 = new Car("宝马");
		Car car3 = new Car("劳斯莱斯");
		Car car4 = new Car("科鲁兹");
		Car car5 = new Car("迈锐宝");
	}
}


以下程序的运行结果是:

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


关于参数传递

练习一

写出结果

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 

和leftShift函数没关系。


练习二

写出结果

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


练习三

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); //0
		ta.change(ta.i);//1
		System.out.println(ta.i); //0
		ta.change1(ta); //1
		System.out.println(ta.i);//1
	}
}


练习四

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


练习五

以下代码的执行结果是什么

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++;
}

答案:i = 0


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';
}

答案:

world

abcde


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) {
		a = 1;
		b = 1;
		c[0] = 1;
	}

	public static void main(String[] args) {
		Test t = new Test();
		t.f();
	}
}

答案:1 0 1


简答

当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递?

答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变,但对象的引用是永远不会改变的


结语


本人会持续更新文章的哦!希望大家一键三连,你们的鼓励就是作者不断更新的动力

你可能感兴趣的:(Java基础习题精练,java,软件工程,开发语言)