Java中的类、对象与继承

类与对象

类的相关概念简介

类：Java程序中的类就是具有类似属性、特性、行为、功能的一类对象的集 合。Java作为面向对象编程语言的一种，类是它的核心概念之一，一个类必须要有类名，在这个类中可以定义一些这个类中其他方法或变量可以共享使用或定义在类中成员方法中的变量（属性）、也可以在一个类中定义一个或多个成员方法，还需要注意的是一个代码中最多只可以有一个或没有public所修饰的类且public所修饰的类名必须与文件名保持一致。
对象：类的对象是具体的，而类是抽象的。比如学生就是一个类，而某个具体的学生就是学生这个类的一个对象。
属性（变量）：类的属性通常用于描述一个类的属性，或者协同类的成员方法完成一些用户需要的功能。
成员方法：类的成员方法是类的行为的描述，它们完成一些特定的功能。

类的相关定义格式

描述类的关键字：class
创建类的对象的关键字：new
类及类相关的元素定义格式：

类：[public或不写] class 类名{ }
对象：对象类型 对象变量名 = new 对象类型();
变量：[访问修饰符] 属性类型 变量名;
成员方法：[访问修饰符]返回值类型 成员方法名(参数类型 参数变量名){方法体}

类及类中元素的命名规范：

类名：首字母大写，其后的每个单词的首字母大写（驼峰式写法）
对象名：首字母小写，其后的每个单词的首字母大写
变量名：首字母小写，其后的每个单词的首字母大写
成员方法名：首字母小写，其后的每个单词的首字母大写  

（p.s:上述的有些命名规范没有严格遵守，可能并不会导致报错，而有些情况则可能会在创建的时候报错，这种情况往往是类名的命名）

类、对象、属性、成员方法的代码示例

class Subject{   //Subject 类
		public String kcname; //Subject 类的属性
		public int kcscore;
		Subject(String name,int score)//Subject 类的构造器
		{
			this.kcname=name;
			this.kcscore=score;
		}
	}

public class Student {  //Student 类
	

		public String name; //Student 类的属性
		public int age;
		public String major;
		public String school;
		public int score;
		Student(String s,int n) //Student 类的构造器
		{
			this.name=s;
			this.age=n;
			this.score=0;
		}
		public void onClass(){ //Student 类的成员方法
			System.out.println("学生"+this.name+"正在上课.");
		}
		public void exam(Subject kc){
			System.out.println(this.name+"通过课程："+kc.kcname+"学分增加："+kc.kcscore);
		}
		public static void main(String[] args) { //程序的入口
			Student student=new Student("min",18); //创建Student类的对象
	        Subject kc=new Subject("线代",4); 
	        student.onClass();   //类的对象使用类的成员方法示例
	        student.exam(kc);
	}
}
/*
output：
学生min正在上课.
min通过课程：线代学分增加：4
// p.s:代码中出现的多处同样的概念我就只注释了一处
*/

继承

继承的概念

Java中使用关键字extends来表示继承的含义，继承可以使导出类具有基类（父类）的属性、成员方法，导出类（子类）具有基类的所有特性，同时还拥有不同于基类的属性、成员方法，它还可以对于基类的成员方法进行重写。

导出类重写基类成员方法

重写的原因：一般是因为基类的成员方法满足不了导出类的需求时，我们就会对基类的成员方法进行重写，而且该基类这个成员方法只能重写一次，重写基类的成员方法之后，基类被重写的成员方法导出类可以通过关键字super来调用它。
重写的格式：除方法体之外，导出类中重写的成员方法访问修饰符、返回值类型、方法名、参数类型必须要与基类的成员方法保持一致。

重写基类成员方法示例

class Car{
	public void sofa(){
		System.out.println("111");
	}
	public void engine(){
		System.out.println("222");
	}
}

public class Test3 extends Car{

	public void sofa(){
		System.out.println("aaa");
		super.sofa();
	}
   
	public void engine(){
		System.out.println("bbb");
	}
	
	public static void main(String[] args) {
		Test3 test=new Test3();
		test.sofa();

	}

}
/*
output:
aaa
111
*/

导出类可调用基类的元素：

1、无论同包与否，基类当中私有的元素导出类都不能进行调用
2、同包的情况下，导出类除了基类中私有的元素外其他的都可以进行调用
3、不同包的情况下，导出类可以调用基类中公共的、受保护的基类元素；非导出类只能调用该基类的公共元素。

向上转型

向上转型通常也是发生在继承的关系当中，这种情况是多态的一种，它是由导出类向上转型为基类，自动转型后的对象不能调用导出类中独有的成员方法。

向上转型示例

//:temp/pk/Pk.java
public class Pk {

	public String name;
	public int hp;
	public int ad;
	public int ap;
	public void ack_1(Pk hero){
		hero.hp-=ad;
		System.out.println(name+"攻击了"+hero.name+"使其失去"+ad+"生命值,剩余"+hero.hp+"生命值");
	}
}
// :temp/pk/DaJi.java
public class DaJi extends Pk{
     public void ack_1(Pk hero){
    	 int sh=(int)(520+1.22*ap);
    	 hero.hp-=sh;
    	 System.out.println(name+"使用技能灵魂冲击"+"使"+hero.name+"失去"+sh+"生命值,剩余"+hero.hp+"生命值");
     }
}
//:temp/pk/LuBan.java
public class LuBan extends Pk{
       public void ack_1(Pk hero){
    	   int sh=(int)(450+0.75*ad);
    	   hero.hp-=sh;
    	   System.out.println(name+"使用技能河豚手雷"+"使"+hero.name+"失去"+sh+"生命值,剩余"+hero.hp+"生命值");
       }
}
//:temp/pk/ZhenJi.java
public class ZhenJi extends Pk{
     public void ack_1(Pk hero){
    	 int sh=(int)(500+0.65*ap);
    	 hero.hp-=sh;
    	 System.out.println(name+"使用技能泪如泉涌"+"使"+hero.name+"失去"+sh+"生命值,剩余"+hero.hp+"生命值");
     }
}
//:temp/pk/Pk1.java
public class Pk1 {

	public static void main(String[] args) {
		LuBan luban=new LuBan();
		luban.name="鲁班大师(001)";
		luban.ad=150;
		luban.ap=20;
		luban.hp=1000;
		DaJi daji=new DaJi();
		daji.name="妲己(002)";
		daji.ad=80;
		daji.ap=130;
		daji.hp=1100;
		ZhenJi zhenji=new ZhenJi();
		zhenji.name="甄姬(003)";
		zhenji.ad=90;
		zhenji.ap=200;
		zhenji.hp=900;
		while(luban.hp>0&&daji.hp>0){
			luban.ack_1(daji);
			if(daji.hp>0)daji.ack_1(luban);
		}
		if(luban.hp>0){
			System.out.println(luban.name+"赢得了第一局.");
			while(luban.hp>0&&zhenji.hp>0){
				luban.ack_1(zhenji);
				if(zhenji.hp>0)zhenji.ack_1(luban);
			}
		}
		else 
			{
			System.out.println(daji.name+"赢得了第一局.");
			while(daji.hp>0&&zhenji.hp>0){
			    daji.ack_1(zhenji);
			    if(zhenji.hp>0)zhenji.ack_1(daji);
			}
		}
		if(luban.hp>0)System.out.println(luban.name+"获得了最终胜利.");
		else if(daji.hp>0)System.out.println(daji.name+"获得了最终胜利.");
		else System.out.println(zhenji.name+"获得了最终胜利.");

	}

}
/*
注意这里并不是一个代码文件.
*/

在ack_1这个成员方法中，我的参数写的是Pk hero，写的是基类类型，如果是写导出类类型的话，那么我们每增加一个新的英雄的时候就都要再写一次ack_1这个成员方法，那么代码就会显得特别的冗长，而向上转型则解决了这个问题，我们只需要将当前导出类作为实参传给ack_1的形参让它自动转型就可以了。

本文地址：https://blog.csdn.net/qq_44836027/article/details/107673351