自家用的java小总结(2.3):类的知识的查漏补缺
首先,这是一篇自己用的文章,不对读者承担任何责任,所以,要带着批判的眼光来看下面的文章
|
发现了,得加上输出结果,怕自己出错,~~
这篇文章说了些什么?
这文章是我近来8.6号来在编程思想上打的代码,从0~200页的源码接近到在这里,下文正是总结这0~200页的的知识,涉及到接口,内部类.初始化,数值计算的一些细节.此文章不会一下子写完,可能隔一天可能再补下来.因为代码确实有点多..
注意
1 我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确),如果你确信我的内容的话,你可能会损失很大,因为我只是个菜鸟,我只是来补救一些知识的而已,如果不复制(最好自己打上)代码运行一次,可能会被我的在代码的注释所误解, 欢迎提意见和评论~~~你的意见和评论是我更新的动力(促进我更快滴读完编程思想)
本文适合读者
适合有一定的编程基础的人,因为我的代码可能出错,建议零基础的人找本书先看看,或者一定要复制我的代码运行一下,否则,后果将不堪设想 <(￣▽￣)> 哇哈哈…因为我也只是新手
再一次提醒
下面的注释只是我个人的总结.
我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确)
,但是注释的语序凌乱各种天花百草不说了.!!!!绝非书本原话!!!!所以要最好还是把我的代码复制下来,运行一遍,也可以把我的注释删掉,或者提示我说应该怎么说,应该怎么说.
再一次感谢
1 感谢你可以抽出你的时间来进行下面阅读,思考的碰撞是智慧产生的前提.谢谢你的阅读和你愿意复制我的代码并阅读我那千奇百怪无比丑的注释来进行思考的碰撞!~!~
正文:
1.一种设计方法,用 switch来进行new对象来实现多态
package polymorphism.shape;
import static net.mindview.util.Print.*;
import java.util.Random;
//用 这个方法来构造多态, 真是神技能
//设置一个基类
//多类口去复写这个类
//然后有个专门的接口去接管这些对象.
//我只要创建这个rand接口劫可以搞定了.
//产生基类对象
class Shape{
public void draw(){};
public void erase(){};
}
class Circle extends Shape{
public void draw(){print("Circle.draw()");}
public void erase(){ print("Circle.erase()");}
}
class Square extends Shape{
public void draw(){ print("Square.draw");}
public void erase(){ print("Square erase");}
}
class Triangle extends Shape{
public void draw(){
print("Triangle.draw()");
}
public void erase(){
print("Triangle.erase()");
}
}
class RandomShapeGenerator{
private Random rand = new Random(47);
public Shape next(){ //每次的next都能产生不同的值.
switch(rand.nextInt(3)){
default:
case 0:return new Circle();
case 1:return new Square();
case 2:return new Triangle();
}
}
}
public class Shapes{
private static RandomShapeGenerator gen
= new RandomShapeGenerator();
public static void main(String[] args) {
Shape[] s= new Shape[9];
for ( int i=0 ; i<s.length ; i++)
s[i]=gen.next();
for ( Shape shp:s)
shp.draw();
}
}
/* output: Triangle.draw() Triangle.draw() Square.draw Triangle.draw() Square.draw Triangle.draw() Square.draw Triangle.draw() Circle.draw() */
2.既然用数组可以搞定 多态,为什么用Vector等容易不可以存储子类的对象?
package test;
import static net.mindview.util.Print.*;
//就算存在无数个继承,也能够被最基础的基类所一一击破
enum Note{
MIDDLE_C,C_SHARP,B_FLAT;
}
class Instrument{
void play(Note n){
print("Wind.play()"+n);
}
String what(){
return "Wind";
}
void adjust(){
}
}
class Wind extends Instrument{
void play(Note n ){
print("WIND.plau()" + n);
}
String what(){
return "Wind";
}
void adjust(){
print("Adjusting Wind");
}
}
class Precussion extends Instrument{
void play(Note n ){
print("precussion.plau()" + n);
}
String what(){
return "percussion";
}
void adjust(){
print("Adjusting Precussion");
}
}
class Stringed extends Instrument{
void play(Note n ){
print("Stringed.plau()" + n);
}
String what(){
return "Stringed";
}
void adjust(){
print("Adjusting Stringed");
}
}
class Brass extends Wind{
void play(Note n ){
print("Brass.plau()" + n);
}
String what(){
return "Brass";
}
void adjust(){
print("Adjusting Brass");
}
}
class Woowind extends Wind{
void play(Note n ){
print("woondwind.plau()" + n);
}
String what(){
return "woddwind";
}
void adjust(){
print("Adjusting woodwind");
}
}
class Music3{
public static void tune(Instrument i){
i.play(Note.MIDDLE_C);
}
public static void tuneAll(Instrument[] e){
for (Instrument i:e){
tune(i);
}
}
public static void main(String[] args) {
Instrument[] orchestra = {
new Wind(),
new Precussion(),
new Stringed(),
new Brass(),
new Woowind()
};
tuneAll(orchestra);
}
}
3.(在这里我想加入运行结果) private是final最终方法,最子类不可见,而且不可覆盖
package test;
import static net.mindview.util.Print.*;
public class PrivateOverride{
//注意private的特性 ,private方法是可以被当前类和类的对象调用,但是不能被其他对象调用.
//而且private对于继承的那个子类是不可见的
// 定义对象,除了static方法,其他的都能用.
//private 而且被认为是 final类,
private int i=3;
private void f(){
print("private f()");
}
public static void main(String[] args) {
PrivateOverride po = new Derived();
po.f();
}
}
class Derived extends PrivateOverride{
public void f(){
print("public f()"); //这里只是覆盖,没有其他问题产生
}
}
/* output
private f()
*/
4.构造器里面的方法的多态
package test;
import static net.mindview.util.Print.*;
class Glyph{
void draw (){
print("Glyph .draw()");
}
public Glyph() {
// TODO 自动生成的构造函数存根
print(" glyph() before draw()"); //在构造器里面避免调用方法,否则,会出现这个draw()的错误
draw(); //但是调用final标志的方法,不会被覆盖,所以可以调用
print("glyph() after draw()");
}
}
class RoundGlyph extends Glyph{
private int radius = 1;
public RoundGlyph(int r) {
// TODO 自动生成的构造函数存根
radius = r;
print(" RoundGlyph.RoundGlyph(),radius = "+radius);
}
void draw(){
print("RoundGlyph.draw() ,radius = " +radius);
}
}
public class PolyConstructors{
public static void main(String[] args) {
new RoundGlyph(5); //整体还是编译的这个对象,
}
}
/*Output glyph() before draw() RoundGlyph.draw() ,radius = 0 glyph() after draw() RoundGlyph.RoundGlyph(),radius = 5 */
5.用多态和子类协助返回类型
import static net.mindview.util.Print.*;
class Grain{
public String toString(){
return "Grain";
}
}
class Wheat extends Grain{
public String toString(){
return "Wheat";
}
}
class Mill{
Grain process(){
return new Grain();
}
}
class WheatMill extends Mill{
Wheat process(){
return new Wheat();
}
}
public class CovariantReturn{
public static void main(String[] args) {
Mill m = new Mill();
Grain g = m.process();
//返回父类的类型 用来协助来返回类型, 也就是我通过一个继承,
System.out.println(g);
m = new WheatMill();
g = m.process();
System.out.println(g);
}
}
6.多态的神招,运用多态来实现多从输出
import static net.mindview.util.Print.*;
//状态设计模式!!!
class Actor{
public void act(){
}
}
class HappyActor extends Actor{
public void act(){
print("HappyActor");
}
}
class SadActor extends Actor{
public void act(){
print("SadActor");
}
}
class Stage{
private Actor actor = new HappyActor();
public void changee (){actor = new SadActor();} //这个神招啊 用向上继承来搞change 就实现了复用
public void performPlay(){ actor.act();}
}
public class Transmogrify{
public static void main(String[] args) {
Stage stage = new Stage();
stage.performPlay();
stage.changee();
stage.performPlay();
}
}
/* Output: HappyActor SadActor */
7.向下转型:
向下转型只是为了易读而设置的.就是实现多态的时候,进行向下转型来提示使用者的类型
class Useful{
public void f(){}
public void g(){}
}
class MoreUseful extends Useful{
public void f(){};
public void g(){};
public void u(){};
public void v(){};
public void w(){};
}
public class RTTI{
//大部分时间都只是为了编译时因为不能识别多态问题而进行的向下转型
public static void main(String[] args) {
Useful[] x= { new Useful() , new MoreUseful()};
x[0].f();
x[1].g();
((MoreUseful)x[1]).u();
((MoreUseful)x[0]).u(); //这里没有编译错误,但是会报异常, 原因是 强制类转换中,没有和他的本类有任何继承关系
}
}
Output:
Useful f() moreuseful f()
浙公网安备 33010602011771号