多态二与常用API

最新推荐文章于 2024-06-24 01:18:16 发布
最新推荐文章于 2024-06-24 01:18:16 发布
阅读量177 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37755380/article/details/88586493
版权

多态的几种形式：
      具体类多态(几乎不用)
      抽象类多态(常用)
      接口多态(最常用)
抽象类：
      A:抽象类和抽象方法必须使用abstract关键字修饰
      B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
      C:抽象类不能实例化
          因为是抽象类，它是抽象的，没有具体的执行，不能直接实例化
          比如动物抽象类，有一个抽象的吃的方法，是真的抽象，没有告诉你具体吃什么
          你实例化出来一只猫，还不得饿死，极其残忍。

抽象类如何实例化呢?
          只能由子类重写抽象方法，使其具体化，才能够间接实例化
          参照多态的方式，父类引用指向子类对象，通过子类对象实例化。

理解:
          抽象类的目的就是为了抽象，抽象出对象必要的共性，由其子类体现个性
          动物为了生存，就必须觅食，那么动物抽象类，就有一个吃的抽象方法，只要你是要吃的，你就是动物类的对象
          如果你知道自己要吃鱼(重写抽象方法)，那么你就是一只活的猫(具体动物类-猫类)
          只要你是要吃的(抽象动物类)，不管你是吃鱼还是啃骨头(多态)站着躺着坐着跪着(子类新增特有方法)
          你也还是动物，不是石头(抽象类的作用给出必要的限定，不能让动物活生生地饿死)
          一只独一无二的上进的猫(实例化对象)，想学学习一下高阶远古遗忘技能猫捉老鼠(接口)
          就来黑猫培训(接口实现类)，帮你走上猫生巅峰(接口实现)
          这里有来自全国各地的喵，一快乐地起捉老鼠
          敬一群沉迷学习无法自拔的编程猫(接口是诗和远方，不是水和面包)
             

抽象类的子类
          要么重写抽象类中的所有抽象方法
          要么是抽象类
          因为抽象类的子类
          会继承父类的抽象方法
          而有抽象方法的类，又必须是抽象类
抽象类的成员特点：
     成员变量：
          有成员变量，成员变量可以是变量，也可以是常量。
      构造方法：
          有构造方法。
          抽象类中构造方法的作用?
          用于子类访问父类数据的初始化。
      成员方法：
          有成员方法，成员方法可以是抽象的，也可以是非抽象的。
          抽象方法：限定子类必须完成某些动作
          非抽象方法：提高代码的复用性

接口：        
    额外扩展的功能
接口的特点：
      A:定义接口使用的是interface关键字
      B:类和接口之间是实现关系，用implements关键字表示
      C:接口不能实例化
          接口有没有其他的方式实例化呢?
          参照多态的形式使用实现类来实例化。
      D:接口的实现类
          要么重写接口中的所有的抽象方法
          要么是一个抽象类
接口成员的特点：
      成员变量：
          有成员变量，变量只能是常量并且是静态的。
          默认修饰符：public static final
      构造方法：
          没有构造方法
          接口不是类，成员变量只能是静态的常量，所以压根不需要初始化
      成员方法：
          有成员方法，而且都是抽象的。
          默认修饰符：public abstract
      接口实现类:
          默认继承Object父类或者可以显示继承父类
          Object是类层次结构的根类，所有的类都直接的或者间接的继承自该类。    

对象、具体类、抽象类、接口之间的联系与区别
    抽象的程度由弱变强
    对象——>具体类——>抽象类——>接口   
类与类：
      继承关系，只能单继承，可以多层继承。
类与接口：
      实现关系，可以单实现，也可以多实现。
      还可以在继承一个类的同时实现多个接口。
接口与接口：
      继承关系，可以单继承，也可以多继承。
抽象类和接口的区别：
     A:成员区别
          抽象类：
              成员变量：可以是变量，也可以是常量
              构造方法：有
              成员方法：可以是抽象方法，也可以是非抽象方法
          接口：
              成员变量：只能是静态常量
              成员方法：只能是抽象方法
      B:关系区别
          类与类：继承关系，只能单继承，可以多层继承
          类与接口：实现关系，可以单实现，也可以多实现
          接口与接口：继承关系，可以单继承，也可以多继承
      C:设计理念的区别
          抽象类 被继承体现的是："is a"    抽象类中定义的是继承体系的共性功能
          接口 被实现体现的是："like a"  接口中定义的是该体系的扩展功能    
     举例：
          猫，动物
          猫，跳高       


/*
 * 需求：猫狗案例，让所有的猫狗具备跳高的额外功能
 * 
 * 分析：从具体到抽象
 * 		猫：姓名，年龄，捉老鼠(){}，吃饭(){}
 * 		狗：姓名，年龄，看门(){}，吃饭(){}
 * 		发现了共性的内容，就提取了一个父类。
 * 		抽象动物类：
 * 			姓名，年龄，吃饭();
 * 		猫：继承抽象动物类
 * 			重写抽象方法
 * 			添加子类特有方法
 * 		狗：继承抽象动物类
 * 			重写抽象方法
 * 			添加子类特有方法
 * 		跳高的额外功能是一个扩展功能，所以应该定义接口实现。
 * 		跳高接口：
 * 			跳高();
 * 		猫：继承抽象动物类，实现跳高接口
 * 		狗：继承抽象动物类，实现跳高接口
 * 实现：从抽象到具体
 * 使用：使用的是具体的类的对象	
 * 		
 */
public class InterfaceTest {
	public static void main(String[] args) {
		
		//具体类多态(参见上一篇帖子-多态)
		//定义本类引用,创建本类对象
		Cat c = new Cat("三脚猫",3);
                //本类引用调用本类对象方法
		c.eat();//3岁的三脚猫 在吃鱼
		c.catchMouse();
		c.jump();//3岁的三脚猫 可以跳高了
		Dog d = new Dog("藏獒", 9);
		d.eat();//9岁的藏獒 在啃骨头
		d.lookDoor();//9岁的藏獒 在看门
		d.jump();//9岁的藏獒 可以跳高了
		
		//抽象类多态
		//父类引用指向子类对象
		Animal a = new Cat("狸花猫",2);
		a.eat();//2岁的狸花猫 在吃鱼
		a = new Dog("乡村土狗", 8);
		a.eat();//8岁的乡村土狗 在啃骨头
		
		//接口多态
		//接口引用指向子类对象(向上转型)
		Jumpping j = new Cat("挪威森林猫",1);
		j.jump();//1岁的挪威森林猫 可以跳高了
		j = new Dog("德国牧羊犬", 7);
		j.jump();//7岁的德国牧羊犬 可以跳高了
		
		//接口类型转换(向下转型)
		System.out.println("-------------接口类型转换---------------");
		Jumpping j2 = new Cat("挪威森林猫2",1);
		j2.jump();//可以跳高了
		//编译报错
		//The method eat() is undefined for the type Jumpping
		//j2.eat();
		//The method catchMouse() is undefined for the type Jumpping
		//j2.catchMouse();
		Cat cat = (Cat)j2;
		cat.jump();//可以跳高了
		cat.eat();//在吃鱼
		//向下转型 运行子类特有方法
		cat.catchMouse();//在捉老鼠
		
		//运行报错
		//com.sz_09.Cat cannot be cast to com.sz_09.Dog
		//Dog dog = (Dog)j2;
		//dog.jump();



	}
}

//跳高接口
public interface Jumpping {
	public abstract void jump();
}
//抽象的动物类
public abstract class Animal {

	private String name;
	private int age;

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

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	public abstract void eat();
}

//具体的猫类
public class Cat extends Animal implements Jumpping {

	public Cat() {
	}

	public Cat(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println(super.getAge()+"岁的"+super.getName()+" 可以跳高了");
	}

	@Override
	public void eat() {
		System.out.println(super.getAge()+"岁的"+super.getName()+" 在吃鱼");
	}

	public void catchMouse(){
		System.out.println(super.getAge()+"岁的"+super.getName()+" 在捉老鼠");
	}
}

 


//具体的狗类
public class Dog extends Animal implements Jumpping {

	public Dog() {
	}

	public Dog(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println(super.getAge()+"岁的"+super.getName()+" 可以跳高了");
	}

	@Override
	public void eat() {
		System.out.println(super.getAge()+"岁的"+super.getName()+" 在啃骨头");
	}

	public void lookDoor(){
		System.out.println(super.getAge()+"岁的"+super.getName()+" 在看门");
	}
}

常用API

Object

/*
 * Object:是类层次结构的根类，所有的类都直接的或者间接的继承自该类。
 * 构造方法：Object()
 * Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）
 * at 标记符“@”和此对象哈希码的无符号十六进制表示组成(地址)
 * 
 * 返回该对象的字符串表示(地址)
 * 
 * 通常，toString 方法会返回一个“以文本方式表示”此对象的字符串
 * 
 * 结果应是一个简明但易于读懂的信息表达式
 * 
 * 建议所有子类都重写此方法
 * 直接输出对象名，输出底层调用的是该对象的toString()
 * 
 * 查看API，我们发现建议所有子类都重写toString()。
 * 到底该如何重写该方法呢?自动生成的就可以。
 */
public class ObjectDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.setName("林青霞");
		s.setAge(30);
		System.out.println(s);
		//System.out.println(s.toString());
		/*
		 public void println(Object x) { //Object x = s;
	        String s = String.valueOf(x);
	        synchronized (this) {
	            print(s);
	            newLine();
	        }
	    }
	    
	    public static String valueOf(Object obj) { //Object obj = x;
        	return (obj == null) ? "null" : obj.toString();
    	}
	    */
	}
}

String

/*
 * String：代表字符串类。
 * 		由多个字符组成的一串数据。
 * 		字符串的本质就是一个字符数组。		
 * 
 * 构造方法：
 * 		String(String original):把字符串数据封装成字符串对象
 * 		String(char[] value):把字符数组的数据封装成字符串对象
 * 		String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
 * 
 * public String toString():返回此对象本身（它已经是一个字符串！）。 
 */
public class StringDemo {
	public static void main(String[] args) {
		String st1 = null;
		/*
		 public static String valueOf(Object obj) { //Object obj = x;
        	return (obj == null) ? "null" : obj.toString();
    	 }
		 * 
		 */
		System.out.println(st1);//null
		String st2 = " ";
		System.out.print(st2);
		System.out.println('s');
		System.out.println("sss----------");
		//String(String original):把字符串数据封装成字符串对象
		String s1 = new String("hello");
		System.out.println(s1);
		System.out.println("----------");
		
		//String(char[] value):把字符数组的数据封装成字符串对象
		char[] value = {'h','e','l','l','o'};
		String s2 = new String(value);
		System.out.println(s2);
		System.out.println("----------");
		
		//String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
		//String s3 = new String(value,0,value.length);
		String s3 = new String(value,0,3);
		System.out.println(s3);
		System.out.println("----------");
		
		//最常用的
		String s4 = "hello";
		System.out.println(s4);
	}
}
/*
 * String类创建对象的特点：
 * 		A:通过构造方法创建对象
 * 		B:通过直接赋值的方式创建对象
 * 这两种方式的创建是有区别的。
 * 通过构造方法创建的字符串对象是在堆内存。
 * 通过直接赋值的方式创建的字符串对象是在方法区的常量池。
 */
public class StringDemo2 {
	public static void main(String[] args) {
		String s1 = new String("hello");
		String s2 = new String("hello");
		
		String s3 = "hello";
		String s4 = "hello";
		
		System.out.println(s1 == s2);//false
		System.out.println(s1 == s3);//false
		System.out.println(s3 == s4);//true
	}
}

 StringBuilder

/*
 * StringBuilder和String的相互转换
 * 
 * StringBuilder -- String
 * 		public String toString():通过toString()就可以实现把StringBuilder转换为String
 * 
 * String -- StringBuilder
 * 		public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
 */
public class StringBuilderTest {
	public static void main(String[] args) {
		
		//StringBuilder -- String
		StringBuilder sb = new StringBuilder();
		sb.append("hello");
		
		//错误的
		//String s = sb;
		//public String toString()
		String s1 = sb.toString();
		System.out.println(s1);
		
		
		//String -- StringBuilder
		String s = "hello";
		StringBuilder sb1 = new StringBuilder(s);
		System.out.println(sb1);
	}
}

 

public class Test {
	public static void main(String[] args) {
		String s = "a";
		s += "b";
		s += "c";
		s += "hello";
		//用工具反编译class文件后的底层代码
		/*
		public static void main(String args[])
		{
			String s = "a";
			s = (new StringBuilder(String.valueOf(s))).append("b").toString();
			s = (new StringBuilder(String.valueOf(s))).append("c").toString();
			s = (new StringBuilder(String.valueOf(s))).append("hello").toString();
		}
		 */
	}
}

Arrays

/* Arrays类有构造方法吗？
 * 通过查源代码
 * private Arrays() {}
 * 
 * Arrays 有构造方法，只不过被private修饰，外界无法使用访问
 * 		     因为外界无法使用访问，所以API中看不到
 * Arrays 工具类的设计思想
 * 		构造方法私有
 * 		成员都用static 修饰
 * 		直接使用类名访问使用
 * 
 * Arrays:提供了对数组操作的各种方法。
 * public static String toString(int[] a):把数组转成字符串
 * public static void sort(int[] a):对数组进行升序排序
 */
public class ArraysDemo2 {
	public static void main(String[] args) {
		//定义一个数组
		int[] arr = {24,69,80,57,13};
		
		//public static String toString(int[] a):把数组转成字符串
		System.out.println("排序前："+Arrays.toString(arr));
		
		//public static void sort(int[] a):对数组进行升序排序
		Arrays.sort(arr);
		
		System.out.println("排序后："+Arrays.toString(arr));
	}
}

Integer 

/*
 * JDK5新特性：
 * 自动装箱：把基本数据类型转换为对应的包装类类型
 *  
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
    public static Integer valueOf(int i) 
 
 * 自动拆箱：把包装类类型转换为对应的基本数据类型

     * Returns the value of this {@code Integer} as an
     * {@code int}.  
     public int intValue() 
 * 
 * Java程序的运行：
 * 		编写java文件 -- 编译生成class文件 -- 执行
 * 
 * 注意：在使用包装类类型的新特性的时候，如果做操作，最好先判断是否为null。
 * 
 * 开发中的原则：
 * 		只要是对象，在使用前就必须进行不为null的判断。
 */
public class IntegerDemo4 {
	public static void main(String[] args) {
		//创建一个包装类类型的对象
		//Integer i = new Integer(100);
		Integer ii = 100; //自动装箱	
		//public static Integer valueOf(int i)
		ii += 200; //ii = ii + 200; 自动拆箱,自动装箱
		//public int intValue()
		System.out.println(ii);
		//用工具反编译class文件后的底层代码
		/*
		Integer ii = Integer.valueOf(100);
		ii = Integer.valueOf(ii.intValue() + 200);
		System.out.println(ii);
		*/
		
		Integer iii = null;
		if(iii != null) {
			iii += 300; //NullPointerException
			System.out.println(iii);
		}
	}
}

Date

/*
 * 工具类
 * 
 * 构造方法私有
 * 成员方法静态
 */
public class DateUtil {
	private DateUtil() {}
	
	/*
	 * 把日期转换为指定格式的字符串
	 * 两个明确：
	 * 		返回值类型：String
	 * 		参数列表：Date date, String format
	 */

	public static String dateToString(Date date,String fomat){
		SimpleDateFormat sdf = new SimpleDateFormat(fomat);
		String s = sdf.format(date);
		return s;
	}
	
	/*
	 * 把指定格式的字符串解析为日期
	 * 两个明确：
	 * 		返回值类型：Date
	 * 		参数列表：String s, String format
	 */

	public static Date stringToDate(String s,String format) throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date d = sdf.parse(s);
		return d;
	}
}
/*
 * 使用今天的Date日期类定义程序 计算一个人出生了多少天
 * 分析:
 * Date时间类以1970-01-01 00:00:00 为基准
 * 1计算生日与基准时间的时长birth
 * 2计算当前时间与基准时间的时长now
 * 3天数 = (now-birth)/1000/60/60/24
 * 
 *  SimpleDateFormat
 *  public Date parse(String source)
 *  public final String format(Date date)
 */
public class Demo {
	public static void main(String[] args) throws ParseException {
		//创建Date对象
		Date now = new Date();;
		System.out.println(now);
		//时间格式化格式
		String format = "yyyy-MM-dd HH:mm:ss";
		//有参构造方式创建SimpleDateFormat对象
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		/**
	     * Parses text from the beginning of the given string to produce a date.
	     * The method may not use the entire text of the given string.
	     * @param source A <code>String</code> whose beginning should be parsed.
	     * @return A <code>Date</code> parsed from the string.
	     * @exception ParseException if the beginning of the specified string
	     *            cannot be parsed.
	     * public Date parse(String source) throws ParseException           
	     */
		Date birth = sdf.parse("2019-03-04 00:00:00");
		/**
	     * Formats a Date into a date/time string.
	     * @param date the time value to be formatted into a time string.
	     * @return the formatted time string.
	     * public final String format(Date date)
	     */
		String dateToString = sdf.format(now);
		System.out.println(dateToString);
		
		long day = (now.getTime()-birth.getTime())/1000/60/60/24;
		System.out.println("已出生:"+day+"天");
	}
}

 

m0_37755380
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
.NET Core WebApi中如何实现多态数据绑定实例代码
10-18
多态数据绑定是一个在面向对象编程中常用的概念，它允许使用父类类型的变量来引用实际的对象实例，这些实例可能是父类的派生类之一。在Web API的上下文中，这涉及到将JSON数据（通常来自客户端的请求体）绑定到方法...
Solidworks二次开发API基础资料库入门
10-07
C#是一种现代化的、面向对象的编程语言，特别适合于.NET框架，因此是Solidworks API开发的常用语言之一。 首先，理解Solidworks API的基础概念至关重要。API提供了一系列的类和方法，这些类和方法对应于Solidworks...
多态、内部类、常用API总结
weixin_43584531的博客
03-03 90
多态 多态是同类型的对象，执行同一个行为，会表现出不同的行为特征。 实现形式： 父类类型 对象名称 = new 子类构造器; 接口 对象名称 = new 实现类构造器; 多态中成员访问特点 方法调用：编译看左边，运行看右边。 变量调用：编译看左边，运行也看左边。（多态侧重行为多态） 多态的前提 有继承/实现关系； 有父类引用指向子类对象；有方法重写。 多态优势： 在多态形式下，右边对象可以实现解耦合，便于扩展和维护。 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类
多态、内部类、常用API
m0_69266818的博客
03-26 500
介绍了面向对象的多态，匿名内部类以及常用的API
多态，内部类，常用API
m0_69599743的博客
03-03 92
多态内部类
JavaSE复习（一）继承多态与常用API
weixin_33965305的博客
04-12 60
继承与多态 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式： 直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上找 间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找 从Java 8 开始，接口里允许定义默认方法 格式 public default 返回值类型 方法名称（参数列表）{ 方法体 } 备注：接口当...
java--多态、内部类、常用API
qq_46606018的博客
06-17 96
什么是多态？ 同类型的对象，执行同一个行为，会表现出不同的行为特征。 多态中成员访问特点 方法调用：编译看左边，运行看右边。 变量调用：编译看左边，运行也看左边。（多态侧重行为多态） 多态的前提 有继承/实现关系； 有父类引用指向子类对象； 有方法重写。优势 在多态形式下，右边对象可以实现解耦合，便于扩展和维护。 （举例：玩具车为父类 有很多子类，车轮/电池。如果电池或车轮坏了，换一个安上去就好） 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。 多态下
多态和接口Api(1)
weixin_52234276的博客
11-12 132
多态:即多种形态 例如：既可以成小王为老师，当然也可以成为人 。 例如：猫，既可以成为猫，也可以归为猫科动物，还可以归为动物 要从多个方面去理解一个事物就会发现事物的的多样性,所以就有了多态 多态要求：必须是有继承或实现的关系，(而且有方法重写) 语法格式：父类类型 变量名 = new 子类类型() public class DuoTaiDemo { public static void main(String[] args) { // 多态的前提下，子父类中方法及属性的调用限制问题 // 子
多态内部类API
weixin_61800817的博客
06-24 875
多态，内部类，API
Java——多态、内部类、常用API
weixin_52135318的博客
10-01 428
1. 面向对象三大特征之一：多态 2. 内部类 3. 常用API
多态、内部类、常用API(java基础进阶)
weixin_46341513的博客
06-28 130
多态、内部类、常用API(java基础进阶)
多态、内部类、常用API part13
m0_54917646的博客
04-28 91
多态的概述、优势、类型转换问题 多态综合案例 内部类 匿名内部类 常用API Object Objects 常用API Stringbuilder 常用API Math System BigDemical 一、多态的概述、优势、类型转换问题 1.面向对象三大特性之三：多态 多态的概述 同类型的对象，执行同一个行为，会表现出不同的行为特征 多态的形式 父类类型 对象名称 = new 子类构造器 接口类型 对象名称= new 实现类构造器 多态中成员...
总结java常用API.doc
07-14
Java常用API总结 Java是一种面向对象的编程语言，具有广泛的应用前景。本文将对Java常用的API进行总结，涵盖面向对象基本概念、System、String、数值、字符、布尔对象与简单类型的操作、Class、ClassLoader、Java ...
大数据处理框架：Flink：FlinkSQL入门与实践.docx
09-02
大数据处理框架：Flink：FlinkSQL入门与实践.docx
数据集成工具：Talend：Talend数据集成最佳实践与案例分析.docx
09-02
数据集成工具：Talend：Talend数据集成最佳实践与案例分析.docx
实时计算：Azure Stream Analytics：数据流窗口与聚合操作.docx
09-02
实时计算：Azure Stream Analytics：数据流窗口与聚合操作.docx
利于python爬虫爬取淘宝司法拍卖和京东司法拍卖土地的每日信息.zip
最新发布
09-02
利于python爬虫爬取淘宝司法拍卖和京东司法拍卖土地的每日信息
51单片机心型流水灯 多种样式
09-02
51单片机 多种花样流水灯
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值