java笔记基础4.docx
《java笔记基础4.docx》由会员分享，可在线阅读，更多相关《java笔记基础4.docx（25页珍藏版）》请在冰豆网上搜索。
java笔记基础4
兄弟连笔记_基础4
41.代码块2
Ø1.普通代码块2
Ø2.构造块2
Ø3.静态块3
42.单例设计模式5
43.继承6
1.继承的基本概念6
2.继承的语法7
3.继承的限制8
4.子类的实例化过程8
5.方法的重写9
6.Super关键字11
7.继承的应用11
44.Final关键字12
45.抽象类13
1.抽象类的基本概念13
2.抽象类的语法13
46.接口15
1.接口的概念15
2.接口的定义15
3.接口的使用规则16
47.多态性17
1.多态性的概念（多种形态）17
2.多态性的两种情况17
3.对象的多态性18
4.多态性小结19
48.Instanceof关键字19
1.语法格式:
19
2.父类的设计原则21
49.抽象类应用21
50.接口应用23
41.代码块
Ø1.普通代码块:
直接写在方法中的代码块,作用域只在最近的{}内,出来{}则不执行
Ø2.构造块:
构造块只在构造对象时执行,在构造对象时调用在类中的代码块,先于构造方法执行.
Ø3.静态块:
在类加载时执行,只执行一次,这个要先于构造块执行
publicclassCodedemo{
//构造块
{
System.out.println（"我是构造块"）;
}
publicCodedemo（）{
System.out.println（"我是构造方法"）;
}
//静态块
static{
System.out.println（"我是静态块"）;
}
publicstaticvoidmain（String[]args）{
Codedemocd1=newCodedemo（）;
//普通代码块
{
Stringinfo="今天天气好晴朗,处处好风光";
System.out.println（info）;
}
//两个info作用域不一样,不会产生冲突
Stringinfo="今天天气好晴朗,处处好风光,应该出去散步了";
System.out.println（info）;
}
}
42.单例设计模式
定义:
保证一个类仅有一个实例,并提供一个访问它的全局访问点
Ø构造方法私有化
Ø声明一个本类对象
Ø给外部提供一个静态方法获取对象实例
两种实现方式:
1.饿汉式（先定义本类对象并实例化）,实际用的多
2.懒汉式（后定义本类对象并实例化）,在多线程访问时会有安全问题,但可以改进
//单例设计模式
publicclassSingleton{
publicstaticvoidmain（String[]args）{
Singleton1s=Singleton1.getInstance（）;
s.print（）;
Singleton1s1=Singleton1.getInstance（）;
System.out.println（s==s1）;
Singleton2s2=Singleton2.getInstance（）;
s2.print（）;
}
}
把该类设计成单例设计模式
饿汉式
classSingleton1{
//先定义一个本类对象并实例化
privatestaticSingleton1s=newSingleton1（）;
//构造方法私有化
privateSingleton1（）{}
publicstaticSingleton1getInstance（）{
returns;
}
publicvoidprint（）{
System.out.println（"饿汉式-单例设计模式"）;
}
}
把该类设计成单例设计模式
懒汉式
classSingleton2{
//先定义一个本类对象为空
privatestaticSingleton2s=null;
//构造方法私有化
privateSingleton2（）{}
publicstaticSingleton2getInstance（）{
if（s==null）{
s=newSingleton2（）;
}
returns;
}
publicvoidprint（）{
System.out.println（"懒汉式-单例设计模式"）;
}
}
43.继承
1.继承的基本概念
●继承是面向对象的三大特征之一
●被继承的类叫父类（超类）,继承父类的类叫子类（派生类）
●继承是指一个对象直接使用另一个对象的属性和方法
●通过继承可以实现代码重用
2.继承的语法
语法:
[访问权限]class子类名extends父类名
{
类体定义;
}
示例:
PublicclassDog{
ProtectedStringname;
}
PublicclassHomeDogextendsDog{
//类的定义
}
3.继承的限制
●Java只能实现单继承,也就是一个类只能有一个父类
●允许多层继承,即:
一个子类可以有一个父类,一个父类还可以有其他的父类
●继承只能继承非私有的属性和方法
●构造方法不能被继承
4.子类的实例化过程
子类在进行实例化操作时,首先会先让其父类进行实例化操作,（调用其默认构造方法,）之后再自己进行实例化操作
/**继承的基本概念
*非私有的:
public（公有的）default（默认的）protected（保护型）（专门为继承使用）
*访问修饰符:
public（公有的）private（私有的）default（默认的）protected（保护型）
子类的实例化过程:
子类的实例化是会先调用父类的默认构造方法
如果父类中没有默认构造方法,在子类的构造方法中必须显示的调用父类构造方法用super调用*/
publicclassExtendsDemo{
publicstaticvoidmain（String[]args）{
HomeChickenhc=newHomeChicken（）;
hc.desc（）;
System.out.println（"------------"）;
Pheasantp=newPheasant（"小白"）;
p.desc（）;
}
}
//父类（超类）
classChicken{
Stringname;
/**默认构造方法
publicChicken（）{
System.out.println（"Chicken"）;
}*/
//带一个参数的构造方法
publicChicken（Stringname）{
System.out.println（"Chicken:
"+name）;
}
publicvoiddesc（）{
System.out.println（"我是一只鸡"）;
}
}
//子类（家鸡）继承了父类的desc方法
classHomeChickenextendsChicken{
publicHomeChicken（）{
super（"小白"）;//super表示父类的引用,调用父类的构造方法语句必须是第一句
System.out.println（"HomeChicken"）;
}
}
//子类（野鸡）继承了父类的desc方法
classPheasantextendsChicken{
publicPheasant（Stringname）{
super（name）;
this.name=name;
System.out.println（"Pheasant"）;
}
}
5.方法的重写
1 方法重写（overidingmethod）
在java中,子类可继承父类中的方法,而不需要重新编写相同的方法.有时子类并不想原封不动继承父类的方法.而是想做一定的修改,这就需要采用方法的重写,方法重写又称方法覆盖
关于方法重写的一些特性:
v发生方法重写的两个方法返回值.方法名.参数列表必须完全一致（子类重写父类的方法）
v子类抛出的异常不能超过父类相应方法抛出的异常（子类异常不能大于父类异常）
v子类方法的访问级别不能低于父类相应方法的访问级别（子类访问级别不能低于父类访问级别）
2 属性重写
在继承关系中,除了方法可以进行覆写之外,属性也是可以进行覆盖操作
注:
该操作在实际应用中不会使用,了解即可
//方法重写
publicclassOveridingmethod{
publicstaticvoidmain（String[]args）{
HomeDoghd=newHomeDog（"小白"）;
hd.desc（）;//此时调用的是子类中的desc
Dogd=newDog（"小黑"）;
d.desc（）;//调用的是父类中的desc
}
}
//父类
classDog{
protectedStringname;
publicDog（Stringname）{
this.name=name;
}
protectedvoiddesc（）{
System.out.println（"mynameis:
"+name）;
}
}
//子类
classHomeDogextendsDog{
publicHomeDog（Stringname）{
super（name）;//调用父类中的属性
}
//desc方法的重写时
publicvoiddesc（）{
System.out.println（"我是:
"+name）;
}
}输出结果:
我是:
小白
mynameis:
小黑
6.Super关键字
Ø使用super可以调用父类中的属性
Ø使用super可以调用父类中的方法
Ø使用super可以调用父类中的构造方法
publicclassSuperKeyWordDemo{
publicstaticvoidmain（String[]args）{
BlackDuckbd=newBlackDuck（"小白",300）;
bd.desc（）;
}
}
classDuck{
protectedStringname;
protectedintprice;
publicDuck（Stringname,intprice）{
this.name=name;
this.price=price;
}
publicvoidcount（）{
System.out.println（"mypriceis:
"+price）;
}
}
classBlackDuckextendsDuck{
publicBlackDuck（Stringname,intprice）{
super（name,price）;//调用父类构造方法
}
publicvoiddesc（）{
System.out.println（"我是一只黑鸭子:
"+super.name）;//调用父类属性
super.count（）;//调用父类方法
}
}
7.继承的应用
见Kiss2ExtendsDemo1.java
见Kiss2ExtendsDemo2.java
44.Final关键字
/**final关键字
*1.final声明一个类.该类不能被继承
*2.final声明一个方法.该方法不能被子类重写
*3.final声明一个常量,用final修饰的属性为常量
*（值不能改变）
*常量的赋值:
1.在声明的同时赋值
*2.通过构造方法赋值
publicclassFinalKeyWordDemo{
publicstaticvoidmain（String[]args）{
}
}
classGril{
finalStringname="小白";//在声明的同时赋值
finalStringsex;
publicGril（Stringsex）{
this.sex=sex;//通过构造方法赋值
}
publicfinalvoiddesc（）{
System.out.println（"我是"+name）;
}
}
45.抽象类
1.抽象类的基本概念
●很多具有相同特征和行为的对象可以抽象为一个类;很多具有相同特征和行为的类可以抽象为一个抽象类
●使用abstract关键字声明的类为抽象类
2.抽象类的语法
声明一个抽象类
PublicabstractclassWomen{
privateStringname;
publicabstractvoidsay（）;//抽象方法
}
抽象类的规则:
Ø抽象类可以没有抽象方法,有抽象方法的类必须是抽象类
Ø非抽象类继承抽象类必须实现所有抽象方法
Ø抽象可以有方法实现和属性
Ø抽象类不能被实例化
Ø抽象类不能被声明为final
Ø可以调用父类的构造方法,但此时的构造方法并不代表实例化对象
publicclassAbstractClassDemo{
publicstaticvoidmain（String[]args）{
Goddessg=newGoddess（）;
g.setName（"咪咪"）;
g.say（）;
UglyWomenu=newUglyWomen（）;
u.setName（"小白"）;
u.say（）;
}
}
abstractclassWomen{
privateStringname;
//构造方法:
此时的构造方法并不代表实例化对象
publicWomen（）{
System.out.println（"我是women"）;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetName（）{
returnname;
}
publicabstractvoidsay（）;//抽象方法（只有声明,没有实现）
}
classGoddessextendsWomen{
//实现父类的抽象方法
publicvoidsay（）{
System.out.println（"我是女神,我是"+getName（））;
}
}
classUglyWomenextendsWomen{
//实现父类的抽象方法
publicvoidsay（）{
System.out.println（"我是丑女,但是我无敌,我是"+getName（））;
}
}
46.接口
1.接口的概念
Ø接口是一组行为的规范.定义,没有实现
Ø使用接口,可以让我们的程序更加利于变化
Ø接口是面向对象编程体系中的思想精髓之一
Ø面向对象设计法则:
基于接口编程
2.接口的定义
接口的定义格式:
Interface接口名称{
全局变量;
抽象方法;
}
示例:
InterfaceHit{
publicvoidcry（）;
}
接口的实现
ClassGoddessimplementsHit{
publicvoidcry（）{
//
}
}
接口的实现
ClassGirlimplementsHit{
publicvoidcry（）{
//
}
}
3.接口的使用规则
✧接口可以继承多个接口（类只能单继承）
✧一个类可以实现多个接口
✧抽象类实现接口可以不实现方法
✧接口中的所有方法的访问权限都是public
✧接口中定义的属性都是常量
✧接口不能被实例化
//接口
publicclassInderfaceDemo{
publicstaticvoidmain（String[]args）{
}
}
interfaceA{}
interfaceB{}
interfaceIEat{//定义接口时按习惯来说,一般前面加I,一目了然
publicvoideat（）;
}
//定义一个接口
//1.接口可以继承多个接口,用逗号隔开
interfaceHitextendsA,B{
//5.在接口中定义的属性都是常量
publicstaticfinalStringNAME="小白";/
//此时的NAME是一个常量,接口中的常量名一般都全大写,publicstaticfinal可以省略
publicabstractvoidcry（）;//抽象方法,没有实现publicabstract可以省略,默认是public//4.接口中所有方法的访问权限都是public
}
//2.一个类可以实现多个接口方法,用逗号隔开
classNvshenimplementsHit,IEat{
//实现接口必须实现接口中的所有方法
publicvoidcry（）{
System.out.println（"疼死了"）;
}
publicvoideat（）{
System.out.println（"一小口"）;
}
}
classGirlimplementsHit{
//实现接口必须实现接口中的所有方法
publicvoidcry（）{
System.out.println（"你妹啊"）;
}
}
//3.抽象类实现接口可以不实现方法
abstractclassPersonimplementsHit{
}
47.多态性
1.多态性的概念（多种形态）
✧多态性是面向对象的三大特征之一
✧什么是多态性
2.多态性的两种情况
✧方法的重载和重写
✧对象的多态性
3.对象的多态性
✧对象的多态性是从多个继承关系中的多个类而来
✧向上转型:
将子类实例转为父类实例
✧格式:
父类父类对象=子类实例;→自动转换
以基本数据类型操作为例:
inti=‘a’;
（因为char的容量比int小.所以可以可以自动完成）
✧向下转换:
将父类实例转为子类实例
以基本数据类型操作为例:
chara=（char）97;
因为整型是4个字节比char2个字节要大,所以需要强制完成
publicclassPolymorphismDemo{
publicstaticvoidmain（String[]args）{
//自动转换（向上转换）
//父类就是大,子类就是小
Personman=newMan（）;//父类的引用指向子类对象
man.say（）;//say方法在父类中必须有,此处的say方法是子类对象中的
Personwomen=newWomen（）;
women.say（）;
//manwomen属于person的两种形态
//强制转换（向下转换）
Manm=（Man）man;//此处man指的是person
m.say（）;
//此时编译没问题,但是运行会出错,因为women和man是同一级,都是子类
//没有父子关系的两种类型不能强制转换
Manm1=（Man）women;
}
}
abstractclassPerson{//人有两种不同的形态
privateStringname;
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetName（）{
returnname;
}
publicabstractvoidsay（）;//抽象方法,没有实现
}
classManextendsPerson{
publicvoidsay（）{
System.out.println（";ujl;sdkf"）;
}
}
classWomenextendsPerson{
publicvoidsay（）{
System.out.println（"ysojskhhshkd"）;
}
✧}
4.多态性小结
✧方法的重载和重写就是方法的多态性的表现
✧多个子类就是父类中的多种形态
✧父类引用可以指向子类对象,自动转换
✧子类对象指向父类引用需要强制转换（注意:
类型不对会报异常）
✧在实际开发中尽量使用父类引用（更利于扩展）
48.Instanceof关键字
1.语法格式:
✧对象instanceof类型--返回boolean类型值
✧该语句一般用于判断一个对象是否为某个类的实例,是返回true,否返回false
publicclassPolymorphismDemo{
publicstaticvoidmain（String[]args）{
Manman=newMan（）;
say（man）;
Womenw=newWomen（）;
say（w）;
}
/**这种静态方法被上面调用时仅用于少量子类
publicstaticvoidsay（Manm）{
m.say（）;
}
publicstaticvoidsay（Womenw）{
w.say（）;
}*/
/**利用多态性解决多子类问题,供以上两类调用
publicstaticvoidsay（Personp）{
p.say（）;
}*/
//用来调用Women中的getangry方法
publicstaticvoidsay（Personp）{
p.say（）;
//判断P对象是否属于Women实例
if（pinstanceofWomen）{
Womenw=（Women）p;
w.getangry（）;
}
}
}
abstractclassPerson{//人有两种不同的形态
privateStringname;
publicvoidsetName（Stringname）{
t
升级会员 