Java - 面向对象三大特性：封装、继承、多态

最新推荐文章于 2024-05-05 18:06:05 发布

xjfy.h

最新推荐文章于 2024-05-05 18:06:05 发布

阅读量1.1k

点赞数 1

分类专栏：【笔记】BigData校内培训-Java入门、进阶

本文链接：https://blog.csdn.net/weixin_42526141/article/details/82785769

版权

【笔记】BigData校内培训-Java入门、进阶专栏收录该内容

10 篇文章 2 订阅

订阅专栏

包：Java中的包机制也是封装的一种形式

语法：package 包名;

注意：

包的声明必须是Java源文件中的第一条非注释性语句
一个Java源文件只能有一个包声明语句
包命名需遵循命名规范

导入包：

语法：import 包名.类名;

面向对象的三大特征：封装、继承和多态。

对象：用来描述客观事物的一个实体
属性：对象具有的各种特征
方法：对象执行的操作

类：具有相同属性和方法的一组对象的集合。类是对象的抽象，对象是类的具体。

类的访问修饰符：

public：可被同一个包或不同包的其他类访问
默认修饰符：只可被同一个包的其他类访问

类成员的访问修饰符：

访问修饰符- static

修饰属性（静态变量）

public static int PERSON_LIVE;

修饰方法（静态方法）

public static void showDetails() {

}

注意：static修饰的属性或方法采用类名加“.”调用

访问修饰符-this

调用重载的构造方法

public Dog(String name,int age,double weight) {
        this(name,age);      //必须是构造方法第一条语句
        this.weight=weight;
}

注意：因为this 是在对象内部指代自身的引用，所以this只能调用实例变量、实例方法和构造方法。this不能调用类变量和类方法，this也不能调用局部变量。

一、封装

封装：用private关键字修饰属性，用private修饰的属性只能在当前类访问，如果外部类想要访问的话，只能通过set和get方法。

封装的好处：隐藏类的实现细节；让使用者只能通过程序员规定的方法（set、get）来访问数据，可以方便的加入存取控制语句，限制不合理操作。

//类：是对象的抽象，对象，是类 的一个具体实例
public class Student {
	//属性：描述对象的静态属性
	//成员变量/全局属性
	String name;   //默认修饰符
	int age;
	char sex; 
	double highth;
	double weigth;
	//访问修饰符：private、protected、public
	//封装，隐藏类的实现细节
	private String tele;
	private String email;
	//使用私有属性用set()/get()方法，设置属性的存取权限
	public void setTele(String tele){
		if (tele == null) {
			//。。。
		}
		this.tele = tele;
	}
	public String getTele(){
		return tele;
	}
	//set()get()配套使用

	public void eat(){
		System.out.println("吃饭。。。");
	}
	public void sleep(){
		System.out.println("睡觉。。。");
	}
	public void act(){
		System.out.println("打豆豆。。。");
	}
}

//方法
	//局部变量：定义在方法中的变量：包括形参，方法中定义的变量在使用之前需要初始化/赋值
	//如果局部变量和全局变量重名，优先使用局部变量
	public void student(String studentName) {
		int times = 3;
		System.out.println(studentName + "一天要吃" + times + "次饭。");
	}
	
	public void add(double age1, double age2){
		System.out.println("两个同学年龄和是：" + age1 + age2);
	}
	
	
	//重载
	public void study(int hour){
		System.out.println("他学习" + hour + "个小时");
	}
	public void study(String subject){
		System.out.println("他学习" + subject);
	}
	//参数类型相同，视为方法相同
//	public void study(int num){
//		System.out.println("他学习" + num + "门课");
//	}

	//普通方法和main方法等级相同，不能在main方法中定义普通方法
	
	//方法重载
	//默认为无参构造方法
	//每个类有一个默认的无参构造器，即时没有定义，在编译的时候系统会自动调用，可以不用手动输入
	//如果如果重载了带参构造器，编译器不会自动加入无参构造器，需要手动加入
	//构造器构造方法，构造器：实例化一个对象
	//
	public Student() {    //无参构造器
		// TODO Auto-generated constructor stub
	}
	Student stud1 = new Student();   //调用了构造器构造方法
	
	//带参构造器
	public Student(String name, int age, char sex,double highth) {
		//this指当前的一个对象
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.highth = highth;
	}  //如果重载了带参构造器，需要把无参构造器手动加入
	//合成一行
	public Student(String name, int age, char sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	Student stud2 = new Student("zhangsan",18,'男');

	//右键，source，generate toString()
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", stud1=" + stud1 + ", stud2=" + stud2
				+ "]";
	}
	
	//菜单栏，source，generate constructor using fields...

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//实例化（new）一个学生对象
		Student stu1 = new Student();
		stu1.name = "张三";
		stu1.age = 18;
		stu1.sex = '男';
		
		Student stu2 = new Student();
		stu2.name = "Amy";
		stu2.age = 16;
		stu2.sex = '女';
		
		//传参时
		//基本数据类型操作传递的是值，引用数据类型传递的是地址
		
		//对象数组：数组里面存储对象
		String [] goods = new String[5];
		Student [] stus = new Student[5];
		Student s1 = new Student();
		s1.name = "张";
		Student s2 = new Student();
		s2.name = "李";
		Student s3 = new Student();
		s3.name = "王";
		for (Student s : stus) {
			System.out.println(s.name + "同学");
		}
		//这样输出没有问题，但会报错：空指针
		//因为定义了数组长度为5，但只打印了3个，第4、5次指针为空
	}

public class Dog {
		static int age = 1;
		//static静态的，修饰的属性和方法是和类一起加载进内存，由类直接调用
		string name = "wangwang";
		double price = 3300;
		public void eat(){
			System.out.println("吃骨头。。");
		}
		public static void eat(String food){
			
			//不能在静态方法中调用非静态方法
			//可以在非静态方法中调用静态方法
		}
		public Dog(){
			super();
		}
		public Dog(String name, double price){
			this();   //调用无参构造器
			this(name);   //调用含有一个参数的构造器
			
			this.name = name;
		}
		
	}
	//main方法中测试
	public static void main(String[] args) {
		Dog.eat("wangcai");
		System.out.println("Dog.age");
		Dog dog = new Dog();   //name 和 age都是初始值
	}

练习1：使用封装实现如下功能：定义包含三个元素的对象数组，数据类型为Student，并使用for循环遍历输出每个学生的年龄。每个学员对象的年龄必须在18-30岁之间。Student类与测试类要求在不同包中。

练习2：一个景区根据游人的年龄收取不同价格的门票。请编写游人类，根据年龄段决定能够购买的门票价格并输出。

游客类：

package com.liudm.demo5;

import java.util.Scanner;

public class Visitor {

	int age;
	
	public Visitor() {
		super();
	}
	public Visitor(int age) {
		super();
		this.age = age;
	}

	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

}

测试类：

package com.liudm.demo5;

import java.util.Scanner;

public class visitorTest {
	public static void main(String[] args) {
		String ans;
		Visitor v1 = new Visitor();

		do {
			System.out.println("请输入年龄：");
			Scanner sc = new Scanner(System.in);
			v1.age = sc.nextInt();

			if(v1.age < 12 || v1.age > 60) {
				System.out.println("门票价格为：10元");
			}
			else if(12 <= v1.age || v1.age <= 60 ) {
				System.out.println("门票价格为：20元");
			}
			
			System.out.println("是否继续？[Y/N]");
			Scanner input = new Scanner(System.in);
			ans = input.next();
		}while("Y".equals(ans));
	}
}

练习3：请通过代码封装，实现如下需求：编写一个类Book，代表教材：具有属性：名称（title）、页数（pageNum），其中页数不能少于200页，否则输出错误信息，并赋予默认值200；
为各属性设置赋值和取值方法：具有方法：detail，用来在控制台输出每本教材的名称和页数；
编写测试类BookTest进行测试：为Book对象的属性赋予初始值，并调用Book对象的detail方法，看看输出是否正确。

Book类：

package com.liudm.demo5;

public class Book {
	String title;
	int pageNum;

	
	public void detail(String title, int pageNum) {
		//this.title = title;
		System.out.println("这本书的书名是：" + this.title);
		if(pageNum < 200) {
			System.out.println("页数出错！");
			this.pageNum = 200;
		}
		//this.pageNum = pageNum;
		System.out.println("这本书的页数是：" + this.pageNum);
	}
	
}

BookTest类：

package com.liudm.demo5;

import java.util.Scanner;

public class BookTest {
	public static void main(String[] args) {
		String ans;
		do{
			Book book1 = new Book();
			System.out.println("请输入图书的书名和页数：");
			
			Scanner scTitle = new Scanner(System.in);
			book1.title = scTitle.next();
			Scanner scPageNum = new Scanner(System.in);
			book1.pageNum = scPageNum.nextInt();
			
			book1.detail(book1.title, book1.pageNum);
			
			System.out.println("是否继续？[Y/N]");
			Scanner input = new Scanner(System.in);
			ans = input.next();
		}while("Y".equals(ans));
	}

}

练习4：创建一个类，为该类定义三个方法，分别执行下列操作：
传递两个整数值并找出其中较大的一个值；
传递三个double值并求出其乘积；
传递两个字符串值并检查其是否相同；
在main方法中测试构造函数的调用。

Calculate类：

package com.liudm.demo5;

public class Calculate {
	int n1,n2;
	double m1,m2,m3;
	String str1,str2;
	
	public Calculate(){
		super();
	}
	
	public void Calculate(int n1, int n2){
		this.n1 = n1;
		this.n2 = n2;
		if (n1 > n2)
			//return n1;
			System.out.println("较大的值为：" + n1);
		else
			//return n2;
			System.out.println("较大的值为：" + n2);
	}
	
	public void Calculate(double m1, double m2, double m3){
		this.m1 = m1;
		this.m1 = m1;
		this.m1 = m1;
		System.out.println("这三个数的乘积为：" + m1*m2*m3);
	}
	
	public void Calculate(String str1, String str2) {
		this.str1 = str1;
		this.str2 = str2;
		if (this.str1.equals(this.str2)) {
			System.out.println("这两个字符串相同");
		}
		else {
			System.out.println("这两个字符串不同");
		}
	}

}

测试类：

package com.liudm.demo5;

import java.util.Scanner;

public class CalculateTest {
	public static void main(String[] args) {
		System.out.println("输入两个整数，找出较大的值：");
		Scanner inputN1 = new Scanner(System.in);
		int n1 = inputN1.nextInt();
		Scanner inputN2 = new Scanner(System.in);
		int n2 = inputN2.nextInt();
		Calculate c1 =  new Calculate();
		c1.Calculate(n1, n2);

		System.out.println("输入三个小数，求他们的积：");
		Scanner inputD1 = new Scanner(System.in);
		double d1 = inputN1.nextDouble();
		Scanner inputD2 = new Scanner(System.in);
		double d2 = inputN2.nextDouble();
		Scanner inputD3 = new Scanner(System.in);
		double d3 = inputN2.nextDouble();
		Calculate c2 =  new Calculate();
		c2.Calculate(d1, d2 ,d3);
		
		System.out.println("输入两个字符串，判断它们是否相同：");
		Scanner inputS1 = new Scanner(System.in);
		String s1 = inputN1.next();
		Scanner inputS2 = new Scanner(System.in);
		String s2 = inputN2.next();
		Calculate c3 =  new Calculate();
		c1.Calculate(s1, s2);
	}

}

练习5：定义一个Cat类（猫类)，为其定义name、age、sex、type、color、eyenum，legnum等字段，其访问修饰符均为private，为Cat类定义构造方法给实例赋值，定义一个ShowData方法，该方法打印猫的信息，
要求：（1）在main方法中创建一个名字为喵喵，年龄为2，性别为雌，品种为加菲猫的对象并调用ShowData()方法打印猫信息；（2）在main方法中实例化一个名字为豆豆，颜色为yellow的对象，并打印其信息（构造器重载）。

练习6：创建一个Teacher类，全局变量为id（只能是0~200之间）、name（长度只能是2~4）、sex、age（只能在20~55之间）、height（1.5~1.8之间），属性全部为私有，在main方法中测试并打印输出在控制台。

实验1：要求：封装学生类（Student），属性包括：姓名、年龄、体重、成绩、性别、国籍；国籍属于静态属性，性别一旦定义赋值不能被修改；编写测试类，给属性赋值并在控制台输出属性值。

Student类：

package com.liudm.demo6;

public class Student {
	private String name;
	private int age;
	private double weight;
	private float score;
	private Object sex;
	public static String nationality = "China";
	
	public Student() {
		// TODO Auto-generated constructor stub
		super();
	}
	public Student(String name, int age, double weight, float score){
		super();
		this.name = name;
		this.age = age;
		this.weight = weight;
		this.score = score;
		//this.sex = sex;
	}
	
	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 setWeight(double weight){
		this.weight = weight;
	}
	public double getWeight(){
		return weight;
	}
	public void setScore(float score){
		this.score = score;
	}
	public float getScore(){
		return score;
	}
	public synchronized void setSex(Object sex1){
		if(sex == null){
			sex = sex1;
		}
		//this.sex = sex;
	}
	public Object getSex(){
		return sex;
	}
	public void setNationality(String nationality){
		this.nationality = nationality;
	}
	public String getNationality(){
		return nationality;
	}
}

测试类：

package com.liudm.demo6;

public class test {
	public static void main(String[] args) {
		Student stu1 = new Student("Sam" , 18 , 70.5 , 87.5f );
		stu1.setSex('男');
		System.out.println("姓名：" + stu1.getName() + "  年龄：" + stu1.getAge() + 
				"  体重：" + stu1.getWeight() + "  成绩：" + stu1.getScore() + 
				"  性别：" + stu1.getSex() + "  国籍：" + Student.nationality);
		
		stu1.setAge(19);
		System.out.println("把年龄改为19后输出信息：");
		System.out.println("姓名：" + stu1.getName() + "  年龄：" + stu1.getAge() + 
				"  体重：" + stu1.getWeight() + "  成绩：" + stu1.getScore() + 
				"  性别：" + stu1.getSex() + "  国籍：" + Student.nationality);

	
		stu1.setSex('女');
		System.out.println("把性别改为女后输出信息：");
		System.out.println("姓名：" + stu1.getName() + "  年龄：" + stu1.getAge() + 
				"  体重：" + stu1.getWeight() + "  成绩：" + stu1.getScore() + 
				"  性别：" + stu1.getSex() + "  国籍：" + Student.nationality);
	}
}

运行结果：

二、继承和多态

继承：将重复代码（共同的属性和方法）抽取到父类中，用于优化设计，单根继承，关键字：extends

继承（extends）是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类。继承就是（1、语义上有继承关系； 2、纯粹为了代码共用）将相同的属性或者方法写到父类中 ,所有的子类共用。

使用继承的好处：方便代码修改，减少代码量（直接在父类里面修改）Java中只支持单根继承，即一个类只能有一个直接父类

子类重写父类方法时，权限需同级或更高，private < protected < public；
参数类型和返回值都相同时才认为是方法重写；
方法重写：在子类中根据需求对从父类继承的方法进行重新编写。父子，在子类中方法名保持一致，修饰符相同或等级更高，返回值一致或是父类方法中返回值对象的子类对象；
在调用方法时，调用的是子类重写过的方法；
声明父类，调用子类重写过的对象。（声明父类，new子类对象）；
方法重载：在同一个类中，方法名相同，参数类型、数量、顺序不同；
Object类是所有类的父类。

继承的使用：

编写父类：

[访问修饰符] class Pet { 
    //公共的属性和方法
}

编写子类，调用父类：

[访问修饰符] class Dog extends Pet { 
    //子类特有的属性和方法
}

继承时构造方法调用顺序：

方法重写：在子类中根据需求对从父类继承的方法进行重新编写。

重写方法和被重写方法必须具有相同的方法名和参数列表
重写方法的返回值类型必须和被重写方法的返回值类型相同或者是其子类
重写方法的不能缩小被重写方法的访问权限

super关键字：

访问父类构造方法

super (参数);      //super代表父类对象

访问父类属性或方法

super.属性名/方法名();

super关键字和this关键字的作用类似，都是将被屏蔽了的成员变量、成员方法变为可见可用。super用在子类中，访问直接父类中的被屏蔽的内容，进一步提高代码的重用性和灵活性。super关键字不仅可以访问父类的构造方法，还可以访问父类的成员，包括父类的属性、一般方法等，无法通过super访问private成员。

Object类：

Object类是所有类的父类
Object类被子类经常重写的方法

多态：同一个引用类型，使用不同的实例而执行不同操作。一种行为，多种状态，即：声明父类，new子类对象，调用方法是子类重写过的方法，所以方法重写是多态的前提。对于父类中的一个方法，不同的子类重写有不同的实现。方法重写是实现多态的基础。

★ 向上转型/向下转型：

向上转型：父类的引用指向子类对象。自动进行类型转换。

<父类型> <引用变量名> = new <子类型>();
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法

向下转型：将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需强制类型转换。

<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

instanceof：Java中提供了instanceof运算符来进行类型的判断，用于减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常。

使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系

A类：

package com.liudm.demo7;

public class A {
	public A(){
		System.out.println("A");
	}
	static {
		//静态代码块
		System.out.println("static A");
	}

}

B类继承A类：

package com.liudm.demo7;

public class B extends A{
	public B(){
		System.out.println("B");
	}
	static {
		//静态代码块
		System.out.println("static B");
	}
}

C类继承B类：

package com.liudm.demo7;

public class C extends B{
	A a = new A();
	public C(){
		B b = new B();
		System.out.println("C");
	}
	static {
		//静态代码块
		System.out.println("static C");
	}
	
	public static void main(String[] args) {
		C c = new C();
	}
}

输出结果：

练习1、写一个Java应用程序，主要是体现父类子类间的继承关系。
父类：鸟；子类：麻雀、鸵鸟、鹰。子类继承父类的一些特点，如都是鸟的话就都会有翅膀、两条腿等属性，但它们各自又有各自的特点，如麻雀的年龄、体重；鸵鸟的身高、奔跑速度；鹰的捕食、飞翔高度等。
编写测试类，调用子类中的方法。

Bird类：

package my.javaoop;
//父类：鸟类
public class Bird{
    //父类共同属性：
    private String wing;//翅膀
    private int leg;//腿
    private String feather;//羽毛

    //共同方法
    public void eat(){
        System.out.println("鸟类都要吃食物: ");
    }
    public String getWing() {
        return wing;
    }
    public void setWing(String wing) {
        this.wing = wing;
    }
    public int getLeg() {
        return leg;
    }
    public void setLeg(int leg) {
        this.leg = leg;
    }
    public String getFeather() {
        return feather;
    }
    public void setFeather(String feather) {
        this.feather = feather;
    }
}

Hawk类：继承（extends）父类Bird，老鹰类除了具有父类Bird类中的属性外，还有自己特有的属性和方法，有颜色属性，飞翔高度等特有的方法。并重写父类中的eat方法。

package my.javaoop;  
//子类：老鹰  
public class Hawk extends Bird {  
    private String color;//颜色  
    //飞翔高度的方法  
    public void flyHieght(double flyHieght ){  
        System.out.println("老鹰飞翔高度 ： "+flyHieght+" 米");  
    }  
    @Override  
    public void eat() {  
        System.out.println("老鹰吃 野鸡、黄鼠、蛇、野兔、蜥蜴、蛙等动物 还吃动物的尸体和牧民丢弃的牛羊肉骨。");  
    }  
    public String getColor() {  
        return color;  
    }  
    public void setColor(String color) {  
        this.color = color;  
    }  
}

Ostrich（鸵鸟）类：让其继承（extends）父类（Bird），这样，子类就可以使用父类中的方法和构造器等，并重写父类中的eat方法。

package my.javaoop;  
//子类：鸵鸟  
public class Ostrich extends Bird {  
    private double height;//身高  
    private float speed;//奔跑速度  
    @Override  
    public void eat() {  
        System.out.println("鸵鸟吃  植物的根、茎、花、果实和小哺乳动物、小昆虫等。。。");  
    }  
    public double getHeight() {  
        return height;  
    }  
    public void setHeight(double height) {  
        this.height = height;  
    }  
    public float getSpeed() {  
        return speed;  
    }  
    public void setSpeed(float speed) {  
        this.speed = speed;  
    }  
}

测试类：

package my.javaoop;  
public class Test {  
    public static void main(String[] args) {  
        Bird bird =new Hawk();//声明父类，new子类对象，如果想调用子类特有的方法时，我们需要向下转型
        //在Hawk类中并没有编写setWing、setLeg、setFeather等方法，但是也能调用，说明调用的是父类中的方法，这就是继承的好处，可以达到代码公用。
        //父类方法
        bird.setWing("老鹰有2条翅膀 ");  
        bird.setLeg(2);  
        bird.setFeather("黑色的羽毛");  
        //System.out.println(bird.getWing()+"  腿条数 "+bird.getLeg()+" 羽毛颜色： "+bird.getFeather());  
  
        //向上转型：将子对象赋给父类使用  
        //Bird bird =new Hawk();  
        //向下转型：将父类引用赋值给子类对象  
        Hawk hawk=(Hawk) bird;  
        //hawk.flyHieght(2000);

        //多态：声明父类Bird的一个变量，分别new两个子类对象，调用eat方法（注意：父类包含eat方法，子类也重写了eat方法），发现调用eat方法时，调用的是子类重写过的方法。即：一种吃的行为，但是不同的子类却有不同体现，这就是多态。
        Bird b1 =new Hawk();  
        Bird b2 =new Ostrich();  
        //调用方法是子类重写过的方法  
        b1.eat();  
        b2.eat();  
  
    }  
}

练习2、实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：
（1）Person类中的属性有：姓名name（String类型）、地址address（String类型）、电话号码telephone（String类型）和电子邮件地址email（String类型）。
（2）Employee类中的属性有：办公室office（String类型）、工资wage（double类型）和受雇日期hiredate（String类型）。
（3）Faculty类中的属性有：学位degree（String类型）、级别level（String类
型）。
（4）Staff类中的属性有：职务称号duty（String类型）
（5）编写测试类

Person类：

package com.liudm.demo7;

public class Person {
	private String name;
	private String address;
	private double wage;
	private String telenumber;
	private String email;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public double getWage() {
		return wage;
	}
	public void setWage(double wage) {
		this.wage = wage;
	}
	public String getTelenumber() {
		return telenumber;
	}
	public void setTelenumber(String telenumber) {
		this.telenumber = telenumber;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	
	
}

Employee类：

package com.liudm.demo7;

public class Employee extends Person{
	private String office;
	private double wage;
	private String hiredate;
	
	public String getOffice() {
		return office;
	}
	public void setOffice(String office) {
		this.office = office;
	}
	public double getWage() {
		return wage;
	}
	public void setWage(double wage) {
		this.wage = wage;
	}
	public String getHiredate() {
		return hiredate;
	}
	public void setHiredate(String hiredate) {
		this.hiredate = hiredate;
	}

}

Faculty类：

package com.liudm.demo7;

public class Faculty extends Employee{
	String degree;
	String level;

	public String getDegree() {
		return degree;
	}
	public void setDegree(String degree) {
		this.degree = degree;
	}
	public String getLevel() {
		return level;
	}
	public void setLevel(String level) {
		this.level = level;
	}

}

Staff类：

package com.liudm.demo7;

public class Staff extends Employee{
	String duty;

	public String getDuty() {
		return duty;
	}
	public void setDuty(String duty) {
		this.duty = duty;
	}
	
}

测试类：

package com.liudm.demo7;

public class Test2 {
	public static void main(String[] args) {
		Faculty f1 = new Faculty();
		f1.setName("zhangsan");
		f1.setTelenumber("123456");
		f1.setOffice("beijing office");
		f1.setWage(3000);
		f1.setLevel("No.2");
		f1.setDegree("本科");
		
		System.out.println("姓名：" + f1.getName() + "\t电话：" + f1.getTelenumber() + "\t级别：" + f1.getLevel());
		System.out.println("办公室：" + f1.getOffice() + "\t工资：" + f1.getWage() + "\t学位：" + f1.getDegree());
		
		System.out.println();
		
		Staff s1 = new Staff();
		s1.setName("lisi");
		s1.setAddress("longxiang street");
		s1.setTelenumber("67890");
		s1.setOffice("shanghai office");
		s1.setWage(9000);
		s1.setDuty("manager");
		
		System.out.println("姓名：" + s1.getName() + "\t地址：" + s1.getAddress() + "\t电话：" + s1.getTelenumber());
		System.out.println("办公室：" + s1.getOffice() + "\t工资：" + s1.getWage() + "\t职位：" + s1.getDuty());
	}
}

练习3、在包com.bxk中编写一个类Father，具有属性：年龄（私有）、姓名（公有）；具有功能：工作（公有）、开车（公有）。
在包com.bxk中编写一个子类Son，具有属性：年龄（受保护的）、姓名；具有功能：玩（私有）、学习（公有）。
最后编写测试类Test，调用子类、父类属性和方法

练习4、编写一个Car类，具有final类型的属性品牌，具有功能drive；
定义其子类Aodi和Benchi，具有属性：价格、型号；具有功能：变速；定义主类E，
在其main方法中分别创建Aodi和Benchi的对象，并测试对象的特性。

练习5、按要求编写一个Java应用程序：
（1）定义一个类，描述一个矩形，包含有长、宽两种属性和计算面积方法。
（2）编写一个类，继承自矩形类，同时该类描述长方体，具有长、宽、高属性和计算体积的方法。
（3）编写一个测试类，对以上两个类进行测试，创建一个长方体，定义其长、宽、高，输出其底面积和体积。

矩形类：

package com.liudm.demo7;

public class Changfangxing {
	private double chang;
	private double kuan;
	
	public double mianji(){
		return this.chang*this.kuan;
	}
	
	public double getChang() {
		return chang;
	}
	public void setChang(double chang) {
		this.chang = chang;
	}
	public double getKuan() {
		return kuan;
	}
	public void setKuan(double kuan) {
		this.kuan = kuan;
	}
}

长方体类：

package com.liudm.demo7;

public class Changfangti extends Changfangxing{
	double gao;

	public double tiji(){
		return this.mianji()*this.gao;
	}
	public double getGao() {
		return gao;
	}
	public void setGao(double gao) {
		this.gao = gao;
	}
}

测试类：

package com.liudm.demo7;

public class Test5 {
	public static void main(String[] args) {
		Changfangxing x = new Changfangxing();
		Changfangti t = new Changfangti();
		
		x.setChang(10);
		x.setKuan(8);
		System.out.println("长方形的面积是：" + x.mianji());
		
		t.setChang(9);
		t.setKuan(6);
		t.setGao(5);
		System.out.println("长方体的底面积是：" + t.mianji());
		System.out.println("长方体的体积是：" + t.tiji());
	}
}

练习6、编写一个类A，该类创建的对象可以调用方法f输出小写的英文字母表。
然后再编写一个A类的子类B，要求子类B必须继承A类的方法f（不允许重写），
子类B创建的对象不仅可以调用方法f输出小写的英文字母表，而且可以调用子类新增的方法g输出大写的英文字母表。
最后编写主类C，在主类的main方法中测试类A与类B。

练习7、编写一个Java应用程序，该程序包括3个类：Monkey、People类和主类E。要求：
（1）Monkey中有个构造方法：Monkey (String s)，并且有个public void speak()方法，在speak方法中输出“咿咿呀呀……”的信息。
（2）People是Monkey的子类，在People类中重写父类的方法speak(),在speak方法中输出“别说话！”的信息。
（3）在People类中新增方法void think()，在think方法中输出“认真思考！”。
（4）在主类E的main方法中创建Monkey与People的对象来测试这两个类的功能。

Monkey类：

package com.liudm.demo7;

public class Monkey {
	String s;
	public Monkey(String s){
		super();
	}
	public void speak(){
		System.out.println("咿咿呀呀...");
	}
	
	public String getS() {
		return s;
	}
	public void setS(String s) {
		this.s = s;
	}
}

People类：

package com.liudm.demo7;

public class People extends Monkey{
	public People(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}
	public void speak(){
		System.out.println("别说话！");
	}
	public void think(){
		System.out.println("认真思考！");
	}
}

测试类：

package com.liudm.demo7;

public class Test7 {
	public static void main(String[] args) {
		Monkey m = new Monkey("一只猴");
		m.speak();
		People p = new People("一个人");
		p.speak();
		p.think();
	}
}

练习8．编写一个Java应用程序，设计一个汽车类Vehicle，包含的属性有车轮个数wheels和车重weight。
小车类Car是Vehicle的子类，其中包含的属性有载人数loader。
卡车类Truck是Car类的子类，其中包含的属性有载重量payload。
每个类都有构造方法和输出相关数据的方法。最后，写一个测试类来测试这些类的功能。

练习9、编写一个Java应用程序，该程序包括3个类： A类、B类和主类E。其中类B是类A的子类，
在子类B中新增了成员变量和成员方法，并且隐藏了父类A的成员变量和重写了父类A的成员方法。
在主类E的main方法中，创建类B的对象并赋给父类A的对象a，使用上转型对象a来测试上转型对象的一些特性。

xjfy.h

关注

1
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
Java - 面向对象三大特性：封装、继承、多态

包：Java中的包机制也是封装的一种形式语法：package 包名;注意：包的声明必须是Java源文件中的第一条非注释性语句一个Java源文件只能有一个包声明语句包命名需遵循命名规范导入包：语法：import 包名.类名;面向对象的三大特征：封装、继承和多态。对象：用来描述客观事物的一个实体属性：对象具有的各种特征方法：对象执行的操作类：具有相同...
复制链接

扫一扫

专栏目录

Java - 面向对象三大特性：封装、继承、多态

一、封装

二、继承和多态

“相关推荐”对你有帮助么？