Java学习day010（oop）：向上造型

最新推荐文章于 2023-02-26 20:56:48 发布
最新推荐文章于 2023-02-26 20:56:48 发布
阅读量213 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litter_m/article/details/105504987
版权
一、引用类型之间画等号

**引用类型变量之间画等号：**指向同一个对象，通过一个引用对数据的修改会影响另一个引用对于数据的访问
eg：房子钥匙
在这里插入图片描述
**基本类型变量之间画等号：**仅仅只做了个赋值操作，对一个变量的修改是不会影响另一个变量的
eg：身份证复印件
在这里插入图片描述

二、向上造型

1. 超类型的引用指向派生类的对象
2. 能点出来什么，看引用的类型


class Animal{
}
class Tiger extends Animal{
}
class Lion extends Animal{
}
Animal o1=new Animal();//一个动物对象时动物类型的（动物是动物）
Tiger o2=new Tiger();//老虎是老虎
Animal o3=new Tiger();//一个老虎对象是动物类型的
//超类   指向   派生类      （向上造型）
//o3.只能点出animal类中的

Tiger o4=new Animal();//动物是老虎——语义不通（编译错误）
//继承要符合 is a（是一个）的关系

FlyingObject[]enemies;//等价于下面一行代码
FlyingObject[]enemies=null;

FlyingObject[]enemies={};//等价于下面一行代码
FlyingObject[]enemies=new FlyingObject[0];
练习
	
	
	/*5 FlyingObject[]enemies;//等价于下面一行代码
		FlyingObject[]enemies=null;
		FlyingObject[]enemies={};//等价于下面一行代码
		FlyingObject[]enemies=new FlyingObject[0];
	     void action(){
	    	 System.out.println(enemies.length);
	     }
	
	     ex x=new ex();
			x.action();*/
	/*4 FlyingObject[]enemies;//等价于下面一行代码
		FlyingObject[]enemies=null;
		FlyingObject[]enemies={};//等价于下面一行代码
		FlyingObject[]enemies=new FlyingObject[0];
	     void action(){
	    	 System.out.println(enemies.length);
	     }
	
	     ex x=new ex();
			x.action();*/
	/*3FlyingObject[]enemies;//等价于下面一行代码
		FlyingObject[]enemies=null;
		FlyingObject[]enemies={};//等价于下面一行代码
		FlyingObject[]enemies=new FlyingObject[0];
	     void action(){
	    	 System.out.println(enemies.length);
	     }
	
	     ex x=new ex();
			x.action();*/
	/*2FlyingObject[]enemies;//等价于下面一行代码
		FlyingObject[]enemies=null;
		FlyingObject[]enemies={};//等价于下面一行代码
		FlyingObject[]enemies=new FlyingObject[0];
	     void action(){
	    	 System.out.println(enemies.length);
	     }
	
	     ex x=new ex();
			x.action();*/
	/*1FlyingObject[]enemies;//等价于下面一行代码
		FlyingObject[]enemies=null;
		FlyingObject[]enemies={};//等价于下面一行代码
		FlyingObject[]enemies=new FlyingObject[0];
	     void action(){
	    	 System.out.println(enemies.length);
	     }
	
	     ex x=new ex();
			x.action();*/

/*5public class Test {

	public static void main(String[] args) {
		Student[] stus;
		stus=new Student[3];
		stus[0]=new Student("zs",25,"lf",111);
		stus[1]=new Student("zz",21,"ss",112);
		stus[2]=new Student("ss",22,"dd",113);
		for(int i=0;i<stus.length;i++){
			System.out.println(stus[i].name);
			stus[i].sayhi();
		}
		Teacher[]tcs=new Teacher[3];
		tcs[0]=new Teacher("sa",54, "kk", 5000);
		tcs[1]=new Teacher("ss",33, "aa", 3000);
		tcs[2]=new Teacher("saa",44, "ss", 4000);
		for(int i=0;i<tcs.length;i++){
			System.out.println(tcs[i].name);
			tcs[i].sayhi();
		}
		Doctor[]dts=new Doctor[3];
		dts[0]=new Doctor("ss",54, "kk", "s");
		dts[1]=new Doctor("sa",33, "aa", "a");
		dts[2]=new Doctor("swa",44, "ss", "b");
		for(int i=0;i<dts.length;i++){
			System.out.println(dts[i].name);
			dts[i].sayhi();
		}
	}

}
class Person{
	int age;
	String name;
	String address;
	Person(String name,int age ,String address){
		this.address=address;
		this.age=age;
		this.name=name;
	}
	void sayhi(){
		System.out.println("hi my name:"+name+";age;"+age+";address:"+address);
	}
}
 class Student extends Person{
	int stuid;
	Student(String name,int age,String address,int stuid){
		super(name,age,address);
		this.stuid=stuid;
	}
}
 class Teacher extends Person{
	int slary;
	Teacher(String name,int age,String address,int slary){
		super(name,age,address);
		this.slary=slary;
	}
}
class Doctor extends Person{
	String leavel;
	Doctor(String name,int age,String address,String leavel){
		super(name,age,address);
		this.leavel=leavel;
	}
}*/
/*4 public class Test {

	public static void main(String[] args) {
		Student[] stus;
		stus=new Student[3];
		stus[0]=new Student("zs",25,"lf",111);
		stus[1]=new Student("zz",21,"ss",112);
		stus[2]=new Student("ss",22,"dd",113);
		for(int i=0;i<stus.length;i++){
			System.out.println(stus[i].name);
			stus[i].sayhi();
		}
		Teacher[]tcs=new Teacher[3];
		tcs[0]=new Teacher("sa",54, "kk", 5000);
		tcs[1]=new Teacher("ss",33, "aa", 3000);
		tcs[2]=new Teacher("saa",44, "ss", 4000);
		for(int i=0;i<tcs.length;i++){
			System.out.println(tcs[i].name);
			tcs[i].sayhi();
		}
		Doctor[]dts=new Doctor[3];
		dts[0]=new Doctor("ss",54, "kk", "s");
		dts[1]=new Doctor("sa",33, "aa", "a");
		dts[2]=new Doctor("swa",44, "ss", "b");
		for(int i=0;i<dts.length;i++){
			System.out.println(dts[i].name);
			dts[i].sayhi();
		}
	}

}
class Person{
	int age;
	String name;
	String address;
	Person(String name,int age ,String address){
		this.address=address;
		this.age=age;
		this.name=name;
	}
	void sayhi(){
		System.out.println("hi my name:"+name+";age;"+age+";address:"+address);
	}
}
 class Student extends Person{
	int stuid;
	Student(String name,int age,String address,int stuid){
		super(name,age,address);
		this.stuid=stuid;
	}
}
 class Teacher extends Person{
	int slary;
	Teacher(String name,int age,String address,int slary){
		super(name,age,address);
		this.slary=slary;
	}
}
class Doctor extends Person{
	String leavel;
	Doctor(String name,int age,String address,String leavel){
		super(name,age,address);
		this.leavel=leavel;
	}
}*/
/*3
public class Test {

	public static void main(String[] args) {


		Student[] stus;
		stus=new Student[3];
		stus[0]=new Student("zs",25,"lf",111);
		stus[1]=new Student("zz",21,"ss",112);
		stus[2]=new Student("ss",22,"dd",113);
		for(int i=0;i<stus.length;i++){
			System.out.println(stus[i].name);
			stus[i].sayhi();
		}
		Teacher[]tcs=new Teacher[3];
		tcs[0]=new Teacher("sa",54, "kk", 5000);
		tcs[1]=new Teacher("ss",33, "aa", 3000);
		tcs[2]=new Teacher("saa",44, "ss", 4000);
		for(int i=0;i<tcs.length;i++){
			System.out.println(tcs[i].name);
			tcs[i].sayhi();
		}
		Doctor[]dts=new Doctor[3];
		dts[0]=new Doctor("ss",54, "kk", 01);
		dts[1]=new Doctor("sa",33, "aa", 02);
		dts[2]=new Doctor("swa",44, "ss", 03);
		for(int i=0;i<dts.length;i++){
			System.out.println(dts[i].name);
			dts[i].sayhi();
		}
	}

}
class Person{
	int age;
	String name;
	String address;
	Person(String name,int age,String address){
		this.name=name;
		this.age=age;
		this.address=address;
	}
	void sayhi(){
		System.out.println(name+age+address);
	}
}
class Student extends Person{
	int suit;
	Student(String name,int age,String address,int suit){
		super(name,age,address);
		this.suit=suit;
	}
}
class Teacher extends Person{
	int slary;
	Teacher(String name,int age,String address,int slary){
		super(name,age,address);
		this.slary=slary;
	}
}
class Doctor extends Person{
	int leavel;
	Doctor(String name,int age,String address,int leavel){
		super(name,age,address);
		this.leavel=leavel;
	}
}*/
/*2
public class Test {

	public static void main(String[] args) {
		Student[] stus;
		stus=new Student[3];
		stus[0]=new Student("zs",25,"lf",111);
		stus[1]=new Student("zz",21,"ss",112);
		stus[2]=new Student("ss",22,"dd",113);
		for(int i=0;i<stus.length;i++){
			System.out.println(stus[i].name);
			stus[i].sayhi();
		}
		Teacher[]tcs=new Teacher[3];
		tcs[0]=new Teacher("sa",54, "kk", 5000);
		tcs[1]=new Teacher("ss",33, "aa", 3000);
		tcs[2]=new Teacher("saa",44, "ss", 4000);
		for(int i=0;i<tcs.length;i++){
			System.out.println(tcs[i].name);
			tcs[i].sayhi();
		}
		Doctor[]dts=new Doctor[3];
		dts[0]=new Doctor("ss",54, "kk", "s");
		dts[1]=new Doctor("sa",33, "aa", "a");
		dts[2]=new Doctor("swa",44, "ss", "b");
		for(int i=0;i<dts.length;i++){
			System.out.println(dts[i].name);
			dts[i].sayhi();
		}
		
	}

}
class Person{
	int age;
	String name;
	String address;
	Person(String name,int age,String address){
		this.address=address;
		this.name=name;
		this.age=age;
	}
	void sayhi(){
		System.out.println(name+age+address);
	}
}
class Student extends Person{
	int suit;
	Student(String name,int age,String address,int suit){
		super(name,age,address);
		this.suit=suit;
	}
}
class Teacher extends Person{
	int slary;
	Teacher(String name,int age,String address,int slary){
		super(name,age,address);
		this.slary=slary;
	}
}
class Doctor extends Person{
	String levael;
	Doctor(String name,int age,String address,String levael){
		super(name,age,address);
		this.levael=levael;
	}
}*/
/*1 
public class Test {

	public static void main(String[] args) {
		Student[] stus;
		stus=new Student[3];
		stus[0]=new Student("zs",25,"lf",111);
		stus[1]=new Student("zz",21,"ss",112);
		stus[2]=new Student("ss",22,"dd",113);
		for(int i=0;i<stus.length;i++){
			System.out.println(stus[i].name);
			stus[i].sayhi();
		}
		Teacher[]tcs=new Teacher[3];
		tcs[0]=new Teacher("sa",54, "kk", 5000);
		tcs[1]=new Teacher("ss",33, "aa", 3000);
		tcs[2]=new Teacher("saa",44, "ss", 4000);
		for(int i=0;i<tcs.length;i++){
			System.out.println(tcs[i].name);
			tcs[i].sayhi();
		}
		Doctor[]dts=new Doctor[3];
		dts[0]=new Doctor("ss",54, "kk", "s");
		dts[1]=new Doctor("sa",33, "aa", "a");
		dts[2]=new Doctor("swa",44, "ss", "b");
		for(int i=0;i<dts.length;i++){
			System.out.println(dts[i].name);
			dts[i].sayhi();
		}
	}

}
class Person{
	int age;
	String name;
	String address;
	Person(String name,int age,String address){
		this.address=address;
		this.age=age;
		this.name=name;
	}
	void sayhi(){
		System.out.println(name+age+address);
	}
}
class Student extends Person{
	int nub;
	Student(String name,int age,String address,int nub){
		super(name,age,address);
		this.nub=nub;
		
	}
}
class Doctor extends Person{
	String leavel;
	Doctor(String name,int age,String address,String leavel){
		super(name,age,address);
		this.leavel=leavel;
		
	}
}
class Teacher extends Person{
	int slary;
	Teacher(String name,int age,String address,int slary){
		super(name,age,address);
		this.slary=slary;
		
	}
}*/

class moo{
	int a;
	void show(){
		
	}
}
class noo extends moo{
	int b;
	void test(){
		
	}
}

public class asdasd {

	public static void main(String[] args) {

		moo o1=new noo();
		o1.a=2;
		o1.show();
		/*5 aoo o2=new boo();
		o2.a=3;
		o2.show();*/
		/*4aoo o3=new boo();
		o3.a=4;
		o3.show();*/
		/*3aoo o4=new boo();
		o4.a=5;
		o4.show();*/
		/*2aoo o5=new boo();
		o5.a=6;
		o5.show();*/
		/*1aoo o6=new boo();
		o6.a=7;
		o6.show();*/
	}

}
/*5 class Aoo{
int a;
void show(){
	
}
}
class boo{
int b;
void test(){
	
}
}*/
/*4 class Aoo{
int a;
void show(){
	
}
}
class boo{
int b;
void test(){
	
}
}
*/
/*3class Aoo{
int a;
void show(){
	
}
}
class boo{
int b;
void test(){
	
}
}
*/
/*2class Aoo{
int a;
void show(){
	
}
}
class boo{
int b;
void test(){
	
}
}
*/
/*1class Aoo{
int a;
void show(){
	
}
}
class boo{
int b;
void test(){
	
}
}*/


		Person[]ps=new Person[7];
		ps[0]=new Student("zs",12,"sa","112");
		ps[1]=new Student("ls", 13, "asd", "113");
		ps[2]=new Student("xc", 14, "vb", "114");	
		ps[3]=new Teacher("lk", 44, "lki", 7000);
		ps[4]=new Teacher("lgy", 66, "sk", 35000);
		ps[5]=new Doctor("asd",21,"asd","s");
		ps[6]=new Doctor("ss",43,"cv","a");
		for(int i=0;i<ps.length;i++){
			System.out.println(ps[i].name);
			ps[i].sayhi();
		}
		/*5 Person[]ps=new Person[6];
		 * ps[0]=new Student("zs",25,"yt","111");
		 * ps[1]=new Student("ll",23,"rt","112");
		 * ps[2]=new Teacher("lz",55,"lk",5555);
		 * ps[3]=new Teacher("ww",44,"jh",6666);
		 * ps[4]=new Doctor("az",45,"gf","s");
		 * ps[5]=new Doctor("er",56,"ds","a");
		 * for(int i=0;i<ps.length;i++){
			System.out.println(ps[i].name);
			ps[i].sayhi();
		}
		 */
		/*4Person[]ps=new Person[6];
		ps[o]=new Student("sa",45,"sa","12212");
		ps[1]=new Student("ds",42,"sd","12213");
		ps[2]=new Teacher("sda",45,"sa",5000);
		ps[3]=new Teacher("saa",45,"sa",6000);
		ps[4]=new Doctor("sa",45,"sa","s");
		ps[5]=new Doctor("sa",45,"sa","a");
		for(int i=0;i<ps.length;i++){
			System.out.println(ps[i].name);
			ps[i].sayhi();
		}*/
		/*3Person[]ps=new Person[3];
		ps[0]=new Student("as",32,"sd","212121");
		ps[1]=new Teacher("ass",32,"sd",10000);
		ps[2]=new Doctor("as",45,"we","a");
		for(int i=0;i<ps.length;i++){
			System.out.println(ps[i].name);
			ps[i].sayhi();
		}*/
		/*2 Person[]ps=new Person[3];
		ps[0]=new Student("ew",32,"sd","455412");
		ps[1]=new Teacher("ares",32,"gd",12000);
		ps[2]=new Doctor("afd",45,"wf","s");
		for(int i=0;i<ps.length;i++){
			System.out.println(ps[i].name);
			ps[i].sayhi();
		}*/
		/*1 Person[]ps=new Person[3];
		 * ps[0]=new Student("SA",45,"sda","212121"0;
		 * ps[1]=new Doctor("DF",12,"asd","a");
		 * ps[2]=new Teacher("zxc",21,"SAd",544554);
		 * for(int i=0;i<ps.length;i++){
		 * System.out.println(ps[i].length);
		 * ps[i].sayhi();
		 * }
		 */
litter_m
关注
java从入门到精通OOP
cgblpx的博客
02-09 1965
文章目录1 面向对象11.1 面向对象1.1.1 概念1.1.2 三大特征1.2 类和对象1.2.1 类1.2.2 对象1.2.3 类和对象的关系1.3 类和对象的创建和使用1.3.1 练习1：类的创建使用1.3.2 对象在内存中的存储1.3.3 单一对象内存图1.3.4 练习2：创建多个类1.3.5 多对象内存图1.4 封装1.4.1 概述1.4.2 private关键字1.4.3 练习1:封装学生1.5 拓展1.5.1 创建Teacher类，并创建Teacher对象测试1.5.2 编写汽车类并画内存图1
JAVA面向对象（OOP）-class 类
break_umbrella的博客
12-27 253
一、Object-Oriented-Programming面向对象编程 1.class 1.构造器：用来初始化值 是默认的无参构造； 2. 使用有参构造的时候必须显示的定义无参构造 3. 使用new 关键字，本质是在调用构造器 package com.f.www.object.oopDemo01; public class Person { //一个类即使什么都不写，它也会存在一个方法-默认的无参构造 //显示的定义构造器 String name="qinjiang"; i
java向上造型的意义，如何理解向上造型有利于提高程序的可扩展性和简洁性，什么时候使用向上造型？
m0_47562022的博客
08-31 2432
先来捋一下什么是向上造型吧 public class Person{ //定义父类Person public void eat(){ System.out.println("person eat"); }; public void shower(){ System.out.println("person shower"); //父类独有方法 } } public class Man extends Person{ //子类
java造型_Java 向上造型详解
weixin_39725365的博客
02-20 288
子类的对象可以向上造型为父类的类型。即父类引用子类对象，这种方式被称为向上造型。在日常生活中，我们都扮演着不一样的角色。我们有可能是老师，有可能是学生，有可能是……， 但是我们都有共同的属性，例如：名字、性别、年龄……，但是在该基础上，不同身份的人也有着属于自己的不同的特点。我们通常描述他人的时候会说，这个人是老师，这个认识学生，这个人是个程序员……。实际上“这个人是……”这种说法就是向上造型。直...
Java向上造型
Java
01-13 1659
Java向上造型
Java中的向上造型
qq_40648768的博客
09-13 195
Java中的向上构型 调用方法:调用的子类重写的方法 下面展示一些 内联代码片。 //父类 public class Person { String name; int age; public void buy(){ System.out.println("普通人买东西"); } } //子类 public class XiaoPing extends Person{ //重写 @Override public void buy() {
向上造型（java）
Ice Point.
02-05 285
不是为了更多的方法而是为了保证参数统一调用 意思为 子类引用的对象转换为父类类型 例如 A 是B的父类 A a = new B(); 向上造型//声明的类是父类，实际创建的是子类 向上造型对象调用方法 可以调用那些方法看父类 方法时具体执行看子类是否重写 优点 参数统一调用 解耦 ...
黑马day02oop-app2
最新发布
HuanLe.的博客
02-26 103
什么是多态
JAVA复习笔记
准备23考研。不定期更新考研知识
07-26 1967
待补充
Java学习笔记
kekekeliang的博客
09-06 251
区别成员变量和局部变量 this.name(类的全局)=name(局部 ) 谁调用方法调用成员方法 成员变量和局部变量不重名的话，可以不加this，最好加，面向对象调用其他构造器（有参、无参）Recusive 递归 Teacher（）{this.(“hello”);} Teacher(String name{} 调用有参构造器，调用那句必须在代码块第一行 this(“李四”)
WM6.5刷机工具
01-31
使用WM手机的，你懂的！！这个就不多说了
java---向上造型
qq_37874262的博客
03-11 227
对于向上造型，很早就接触了，但是今天突然想起一个问题，就写了一个测试类，发现自己理解的还不够全面。 直接上代码： public class A{ public void b(){ System.out.println("a.b"); } } class B extends A{ public void c(){ System.out.println("b.b");...
向上造型Java
jokerxue___的博客
07-10 1496
向上造型
向上造型 java_java中的向上造型
weixin_29603489的博客
02-19 424
package Demo;/***測試向上造型*所謂的向上造型就是 父類的引用(棧中)指向子類的對象(堆中)* 打個比喻：* 人是父類，學生是子類。 人能夠吃飯，說話； 學生能夠吃飯(重寫)，學習；(學生吃飯方法是獨特的)* 當學生向上造型為人時，我們再調用吃飯這個方法時，我們調用的其實是學生特有的吃飯方法；* 下面的例子大家可以好好想想，分別運用到，繼承，方法重寫，構造方法初始化成員變量，向上造...
Java 多态,向上造型
huyao的博客
07-17 1553
首先我们来定义四个类， 分别是动物类、猫类、狗类、动物信息类，  猫类和动物类都继承了动物类，并且都有自己单独的属性。但是在动物信息类中我们定义了一个是动物类的ArrayList，每次new进去的是猫或者狗，但系统知道这是什么，就是说我一各动物列表，里面可以方任何动物，我也可以管理任何动物，任何动物的属性都在这里得到保留。 多态条件：  1，有继承的存在。2，子类重写父类方法。3，父类引用
java转型 内存_Java向上转型及内存分析
weixin_39846186的博客
02-27 112
学习设计模式的时候，发现很多模式都用到了向上转型(eg. 工厂方法)。而我对向上转型(upcasting)的机制并不十分熟悉。这篇文章将深入分析向上转型的机制、内存分析。概念先从几个基本概念开始：1. Java中的引用类型(reference type)Java中的数据类型分为两类：基本数据类型(int, double)和引用类型(String)。引用类型对象中保存着一个地址(称为“引用”)，引用...
Java:向上造型与向下造型
zhbin6的博客
10-02 375
Java:向上造型与向下造型向上造型向下造型总结 前言：众所周知，四边形包括正方形、长方形、平行四边形、菱形等图形。接下来用四边形例子来说明向上造型与向下造型。 向上造型 将一个较具体的类转换到一个较抽象的类。 //四边形类 class Quadrangle{ public static void draw(Quadrangle q){ //do something } } //正方形类 class Square extends Quadrangle{ public static void ma
Java的向上造型和向下造型。。。
愿景.青城雪
08-30 230
java class A { } class B extends A { } A a = new A(); B b = new B(); A a1 = b;// 向上造型 B b1 = (B) a1; // 向下造型 B b2 = a; // ClassCastException,a的类型是A,实例化也是A 向上造型： 父类引用指向子类对象（子类型，实例也是子类的...
Java：多态变量和向上造型
qq_48510607的博客
05-06 952
接上文：Java：继承 多态变量 我们定义了一个类出来，就是定义了一个新的类型，这个新的类型可以用来定义变量，可以制造类的对象存入定义的变量中（变量是管理者）。 类定义了类型,DVD类所创建的对象的类型就是DVD。类可以有子类,所以由那些类定义的类型可以有子类型。在下面的例子中,DVD类型就是Item类型的子类型。 **子类型类似于类的层次,类型也构成了类型层次。**子类所定义的类型是其超类的类型的子类型。 当把一个对象赋值给一个变量时,对象的类型必须与变量的类型相匹配,如: Car myCar =
Java OOP：封装、继承与多态解析
"面向对象编程（OOP）是Java的核心特性，包括封装、继承和多态。封装是隐藏类内部细节，提高程序安全性的方法，通过使用private修饰符实现。访问封装的属性通常需要通过getter和setter方法。继承则是让一个类（子类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值