关闭

day08

66人阅读 评论(0) 收藏 举报
分类:

什么是多态

事物的多种形态,把子类对象看成是父类对象(把子类对象赋给父类的某一个变量),但是在运行时期,运行的是子类的特征

多态的好处

可以屏蔽不同子类对象之间的差异,从而写出通用的代码实现通用编程

多态时方法调用的问题

情况1:subclass和superclass,dowork只存在于subclass中,不存在superclass这样编译就会报错.

情况2:dowork是静态方法,都存在于两个类中,但是在执行的时候是执行的父类的dowork    静态方法属于隐藏

superclass su = new subclass();
su.dowork();//执行的是父类方法,静态方法只是
情况3:

class superclass{
	public void dowork(){
		System.out.println("我是父");
	}
}
class subclass extends superclass{
	public void dowork(){
		System.out.println("我是子");
	}
}
public class demo{
	public static void main(String[] args){
		superclass cl = new subclass();
		cl.dowork();
	}
}
引用类型转换

需要使用特有属性,就需要使用强转. instanceof

class superclass{
	public void dowork(){
		System.out.println("我是父");
	}
}
class subclass extends superclass{
	public void dowork(){
		System.out.println("我是子");
	}
	public void doo(){
		System.out.println("我是子类特有的方法");
	}

}
public class demo{
	public static void main(String[] args){
		superclass cl = new subclass();
		cl.dowork();
			if(cl instanceof subclass){
				System.out.println("转换开始");
				subclass su = (subclass)cl;
				su.doo();
		}
	}
}
代码块

在程序中,使用{}括起来的一段代码,而根据代码块的位置和修饰符可以分三种

1,局部代码块,在方法中定义的代码块,一般的表现为if for语句

2,初始化代码块,在类中直接定义的,和方法是平行关系,用来初始化操作,在创建该初始化代码块所在类的对象的时候,执行,创建N个对象,则执行N次.

   创建对象时,优先于构造器执行

3,静态代码块,使用static修饰的初始化代码块,当静态代码块所在类的字节码被加载进jvm,就立马执行静态代码块,而且只会执行一次.

class codedemo{
	codedemo(){
		System.out.println("构造器");
	}
	{
		System.out.println("初始化代码块");
	}
	static{
		System.out.println("静态代码块");
	}
	public static void main(String[] args){
		System.out.println("main....");
		new codedemo();
		new codedemo();
		new codedemo();

	}
}
Final修饰符

最终的,不能改变的,是一个修饰符,可以修饰类,方法,变量

final修饰的类,不能有子类.

某类不是专门为继承而设计的

出于安全考虑,类的实现细节不许改动

确信该类不会被扩展

final修饰的方法:最终方法,该方法不能被子类所覆盖

父类在构造器中调用的初始化方法

父类中提供好的算法业务操作,只应该让子类调用,不能被子类继承

常量

字面值,直接量,"abc",3

使用final修饰的变量

final是所有修饰符中唯一可以修饰局部变量的修饰符

final变量,最终变量,只有一次赋值的机会

起名全部是大写,多个字母使用_分开

final修饰引用类型常量

所引用的堆内存地址值不能改变

单例设计模式

满足三个条件,

1\构造器私有

2\工具类自身先提供好一个对象

3\工具类向外暴露一个公共的静态方法,用于返回该对象

public class danli{
	private danli(){}
	private static final danli instance = new danli();
	public static danli getInstance(){
		return instance;
	}
}
基本类型包装类

Byte Short Integer Character Float Double Long Boolean

装箱

Integer i1 = new Integer(1);

Integer i2 = Integer.valueOf(1);

拆箱

int num = i1.intValue();

从java5开始就支持自动装箱和拆箱了

Integer i3 = 18;

int num3 = i3;

//String 和 int 相互间的转换
public class demo2{
	public static void main(String[] args){
		String str = "17";
		int num = Integer.parseInt(str);
		System.out.println(num);
		String str2 = String.valueOf(num);
		System.out.println(str2);
	}
}
享元模式

共享同一个元素/带有缓存设计

Byte,Short,Integer,Long -128 ~ +127

Character 0~127

public class demo3{
	public static void main(String[] args){
		Byte a = 18;
		Byte b = 18;
		System.out.println(a==b);//true
		Character c1 = 128;
		Character c2 = 128;
		System.out.println(c1==c2);//false
	}
}
引出抽象

需要在

抽象方法只存在于接口和抽象类中

abstract class demo{
	abstract public void method();
}
class demotest extends demo{
	public void method(){
		System.out.println("我只是覆盖方法而已");
	}
}
public class demo4{
	public static void main(String[] args){

	}
}





0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:2054次
    • 积分:280
    • 等级:
    • 排名:千里之外
    • 原创:27篇
    • 转载:1篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档