学习java 第七天 继承封装多态重载

已于 2024-10-17 22:55:37 修改
阅读量464 收藏 11
点赞数 11
文章标签： 学习 java 开发语言
于 2024-10-14 19:07:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Miserables_/article/details/142925908
版权

一.自动排序

利用了Arrays 的一个方法进行排序，只能是升序 应用范围受限制

int[] data={4,9,8,1,2,5,6,3};
		//只能按照数字升序 了解一下 //自动排序  介绍完毕
		Arrays.sort(data);

		for(int x:data){
			System.out.print(x+" ");
		}

二.引用数据的数组+封装

这是普通的写法

封装：将属性进行private 然后增加 setter 和getter方法  封装以后的属性只能在该类体被访问

注意：并不是所有情况必须同时提供两个 public 方法，如果需求是可以获取属性值但是不可以修改，只提供属性的 getter 方法，此时不 提供setter 方法。 
import java.util.*;
public class Exec1{
	public static void main(String[] args){
		// 创建一个学生数组-可以存放4个学生信息
		Student[] stu=new Student[4];

		// Jack 20 100 '男'
		// Anron 22 78 '男'
		// Amy 19 98 '女'
		// Tom 23 100 '男'

		Student s1=new Student();
		Student s2=new Student();
		Student s3=new Student();
		Student s4=new Student();

		s1.name="Jack";
		s1.age=20;
		s1.score=80;
		s1.gender='男';

		s2.name="Anron";
		s2.age=22;
		s2.score=78;
		s2.gender='男';

		s3.name="Amy";
		s3.age=19;
		s3.score=58;
		s3.gender='女';

		s4.name="Tom";
		s4.age=23;
		s4.score=90;
		s4.gender='男';

		//加到数组里
		stu[0]=s1;
		stu[1]=s2;
		stu[2]=s3;
		stu[3]=s4;



		// 1 按照学生的分数升序排序- 冒泡

		for(int i=0;i<stu.length-1;i++){
			for(int j=0;j<stu.length-1-i;j++){
				if(stu[j].score>stu[j+1].score){
					Student temp=new Student();
					temp=stu[j];
					stu[j]=stu[j+1];
					stu[j+1]=temp;
				}
			}
		}



		// 2 将所有不及格学生姓名打印出来 for + 下标
		for(int i=0;i<stu.length;i++){
			if(stu[i].score<60){
				System.out.println(stu[i].name);
			}
		}

		// 3 统计全班的总分 foreach
		int sum=0;
		for(Student x:stu){
			sum=sum+x.score;

		}
		System.out.println("全班级总分 "+sum);

		// 4 得到全班的最高分和他的姓名 foreach
		/*int max=stu[0].score;
		String name1=stu[0].name;
		for(Student x:stu){
			if(x.score>max){
				max=x.score;
				name1=x.name;
			}
		}

		System.out.println("全班最高分:"+max+" 姓名："+name1);*/
		Student maxStu=stu[0];
		for(Student x:stu){
			if(maxStu.score<x.score) maxStu=x;
		}
		System.out.println("全班最高分:"+maxStu.score+" 姓名："+maxStu.name);

		// 5 按照学生的年龄降序排序
		for(int i=0;i<stu.length-1;i++){
			for(int j=0;j<stu.length-1-i;j++){
				if(stu[j].age<stu[j+1].age){
					Student temp=new Student();
					temp=stu[j];
					stu[j]=stu[j+1];
					stu[j+1]=temp;
				}
			}
		}
		//排序完了打印一下看看
				for(int i=0;i<stu.length;i++){
					stu[i].show();
		}

	}
}
/**
	创建一个学生类 Student
		学生有 name age score gender
		学生会 show()
			show():打印 XXX今年XXX岁 这次考了XXX分
*/

class Student{
	String name;
	int age;
	int score;
	char gender;

	public void show(){
		System.out.println(name+"今年"+age+"岁 这次考了"+score+"分");
	}
}

进行封装

import java.util.*;
public class Exec1_1{
	public static void main(String[] args){
		// 创建一个学生数组-可以存放4个学生信息
		Student[] stu=new Student[4];

		// Jack 20 100 '男'
		// Anron 22 78 '男'
		// Amy 19 98 '女'
		// Tom 23 100 '男'

		Student s1=new Student();
		Student s2=new Student();
		Student s3=new Student();
		Student s4=new Student();


		s1.setName("Jack");
		s1.setAge(20);
		s1.setScore(80);
		s1.setGender('男');


		s2.setName("Anron");
		s2.setAge(22);
		s2.setScore(78);
		s2.setGender('男');


		s3.setName("Amy");
		s3.setAge(19);
		s3.setScore(58);
		s3.setGender('女');


		s4.setName("Tom");
		s4.setAge(23);
		s4.setScore(90);
		s4.setGender('男');
		//加到数组里
		stu[0]=s1;
		stu[1]=s2;
		stu[2]=s3;
		stu[3]=s4;



		// 1 按照学生的分数升序排序- 冒泡

		for(int i=0;i<stu.length-1;i++){
			for(int j=0;j<stu.length-1-i;j++){
				if(stu[j].getScore()>stu[j+1].getScore()){
					Student temp=new Student();
					temp=stu[j];
					stu[j]=stu[j+1];
					stu[j+1]=temp;
				}
			}
		}



		// 2 将所有不及格学生姓名打印出来 for + 下标
		for(int i=0;i<stu.length;i++){
			if(stu[i].getScore()<60){
				System.out.println(stu[i].getName());
			}
		}

		// 3 统计全班的总分 foreach
		int sum=0;
		for(Student x:stu){
			sum=sum+x.getScore();

		}
		System.out.println("全班级总分 "+sum);

		// 4 得到全班的最高分和他的姓名 foreach
		/*int max=stu[0].score;
		String name1=stu[0].name;
		for(Student x:stu){
			if(x.score>max){
				max=x.score;
				name1=x.name;
			}
		}

		System.out.println("全班最高分:"+max+" 姓名："+name1);*/
		Student maxStu=stu[0];
		for(Student x:stu){
			if(maxStu.getScore()<x.getScore()) maxStu=x;
		}
		System.out.println("全班最高分:"+maxStu.getScore()+" 姓名："+maxStu.getName());

		// 5 按照学生的年龄降序排序
		for(int i=0;i<stu.length-1;i++){
			for(int j=0;j<stu.length-1-i;j++){
				if(stu[j].getAge()<stu[j+1].getAge()){
					Student temp=new Student();
					temp=stu[j];
					stu[j]=stu[j+1];
					stu[j+1]=temp;
				}
			}
		}
		//排序完了打印一下看看
				for(int i=0;i<stu.length;i++){
					stu[i].show();
		}

	}
}
/**
	创建一个学生类 Student
		学生有 name age score gender
		学生会 show()
			show():打印 XXX今年XXX岁 这次考了XXX分
*/

class Student{
	private String name;
	private int age;
	private int score;
	private char gender;

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

	public String getName(){
		return this.name;
	}

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

	public int getAge(){
		return this.age;
	}
	public void setScore(int score){
		this.score=score;
	}
	public int getScore(){

		return score;
	}

	public void setGender(char gender){
		this.gender=gender;
	}
	public char getGender(){
		return this.gender;
	}
	public void show(){
		System.out.println(this.name+"今年"+this.age+"岁 这次考了"+this.score+"分");
	}
}

三.面向对象的特点

面试题：面向对象的 特点 有哪些？
三个：封装 继承 多态
四个：封装 继承 多态 抽象

 四.继承

继承 - 用 extends 实现两个类之间 is a 的关系
两个类？父类和子类【子类 extends 父类】
is a ? 是一个 / 是一种
继承的作用？继承的优点？
可以利用继承 实现 共享代码
继承的缺点？
单根继承
面试题：封装和继承冲突吗？
不冲突 
public class Exec03{
	public static void main(String[] args){
		Student stu=new Student();
		Teacher tt=new Teacher();
		Police pl=new Police();
		Person p1=new Student();
		Person p2=new Teacher();
		Person p3=new Police();

		RestRoom rr=new RestRoom();
		rr.toilet(stu);
		rr.toilet(tt);
		rr.toilet(pl);

		rr.toilet(p1);
		rr.toilet(p2);
		rr.toilet(p3);


	}
}
/*
	定义一个Student类型：
		有的属性：name  age  stuId
		会的方法：eat()  sleep()  study()
	定义一个Teacher类型：
		有的属性：name  age  salary
		会的方法：eat()  sleep()  teach()
	定义一个Police类型：
		有的属性：name  age  jingHao
		会的方法：eat()  sleep()  poan()
	定义一个RestRoom厕所类：
		提供上厕所的方法：
			学生可以上厕所
			老师可以上厕所
			警察可以上厕所

	封装 继承 多态
*/
class Person{
	private String name;
	private int age;


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

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

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

	public void eat(){
		System.out.println("会吃饭饭");
	}
	public void sleep(){
		System.out.println("会睡觉觉");
	}
}
class Student extends Person{
	private int stuId;

	public void setStuId(int stuId){
		this.stuId=stuId;

	}
	public int getStuId(){
		return this.stuId;
	}
	public void study(){
		System.out.println("会学习");
	}
}

class Teacher extends Person{
	private double salary;

	public void setSalary(double salary){
		this.salary=salary;
	}
	public double getSalary(){
		return salary;
	}

	public void teach(){
		System.out.println("会教学");
	}
}
class Police extends Person{
	private int jingHao;

	public void setJingHao(int jingHao){
		this.jingHao=jingHao;
	}
	public int getJingHao(){
		return jingHao;
	}

	public void poAn(){
		System.out.println("会破案");
	}
}
//无他 唯手熟尔
class RestRoom{
	public void toilet(Person pp){
		System.out.println(pp.getClass().getName()+"会上厕所");
	}
}

五.多态

一个对象可以使用不同类型去描述【多态前提：继承】
多态的作用？
创建对象： [ 了解 ]
父类类型 dd = new 子类类型 ();
缺点 ： dd 只可以调用父类和子类共有的内容【属性 / 方法】
dd 不能调用子类特有的内容【属性 / 方法】
方法： 降低耦合度【解耦】
方法定义 ( 父类类型 参数名 );
方法调用 ( 子类对象 ); 
public class Exec3{
	public static void main(String[] args){
		Car cc=new Car();
		BaoMa bb=new BaoMa();
		Car c1=new BaoMa();

		XiuCheChang xiuChe=new XiuCheChang();
		xiuChe.fix(c1);

	}

}

class XiuCheChang{
	public void fix(Car type){
		System.out.println("可以修理"+type.getClass().getName());
	}

}
class Car{//车
}

class BaoMa extends Car{
}

class BenChi extends Car{
}

class LiXiangChe extends Car{
}

六.重载

方法重载满足的条件

必须发生在同一个类体

必须方法名必须一致

方法参数必须不同
     1.类型不同  

     2.个数不同

     3.顺序不同

重载与返回类型无关  修饰符无关  参数名无关

class A{
	public void test(){
		System.out.println("test111");
	}
}

class B extends A{
	public void test(int aaa){
			System.out.println("test222");
	}
}

/*面试题：上述代码有重载吗
   谁和谁构成  B继承A中的test和B中的test进行了重载*/

方法重载的作用？

满足客户的不同需求

Miserables_
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值