自家用的java小总结(2.4):类的知识的查漏补缺
|
|
1
|
发现了,得加上输出结果,怕自己出错,~~ |
这篇文章说了些什么?
这文章是我近来8.6号来在编程思想上打的代码,从0~200页的源码接近到在这里,下文正是总结这0~200页的的知识,涉及到接口,内部类.初始化,数值计算的一些细节.此文章不会一下子写完,可能隔一天可能再补下来.因为代码确实有点多..
注意
1 我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确),如果你确信我的内容的话,你可能会损失很大,因为我只是个菜鸟,我只是来补救一些知识的而已,如果不复制(最好自己打上)代码运行一次,可能会被我的在代码的注释所误解, 欢迎提意见和评论~~~你的意见和评论是我更新的动力(促进我更快滴读完编程思想)
本文适合读者
适合有一定的编程基础的人,因为我的代码可能出错,建议零基础的人找本书先看看,或者一定要复制我的代码运行一下,否则,后果将不堪设想 <(￣▽￣)> 哇哈哈…因为我也只是新手
再一次提醒
下面的注释只是我个人的总结.
我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确)
,但是注释的语序凌乱各种天花百草不说了.!!!!绝非书本原话!!!!所以要最好还是把我的代码复制下来,运行一遍,也可以把我的注释删掉,或者提示我说应该怎么说,应该怎么说.
再一次感谢
1 感谢你可以抽出你的时间来进行下面阅读,思考的碰撞是智慧产生的前提.谢谢你的阅读和你愿意复制我的代码并阅读我那千奇百怪无比丑的注释来进行思考的碰撞!~!~
正文:
1.抽象类
抽象类里面 可以有抽象方法,也可以没有抽象方法. 但是有抽象方法必须是抽象类....
2.接口方法.
策略设计模式: 1.在类里面设计一个方法,用该方法来强制一个对象来使用方法
package test;
import java.util.*; //也是通过上诉造型,进行Object的类型转换,(从强转就可以得到相应的类型)
//策略模式
class Processor
{
public String name()
{
return getClass().getSimpleName(); //返回当前调用该函数的NAME
}
Object process(Object input)
{
return input; //父类创建Object返回一个Object 对象
}
}
class Upcase extends Processor
{
String process(Object input)
{
return ((String)input).toUpperCase(); //继承的时候换个Processor
}
}
class Downcase extends Processor
{
String process(Object input)
{
return ( (String)input).toLowerCase();
}
}
class Splitter extends Processor
{
String process (Object input)
{
return Arrays.toString( ( (String)input).split(""));
}
}
public class Apply
{
public static void process(Processor p,Object s)
{
System.out.println("Using Processor"+p.name());
System.out.println(p.process(s));
}
public static String s = "hello world";
public static void main(String[] args)
{
process(new Upcase(),s);
process(new Downcase(),s);
process(new Splitter(),s);
}
}
Using ProcessorUpcase HELLO WORLD Using ProcessorDowncase hello world Using ProcessorSplitter [, h, e, l, l, o, , w, o, r, l, d]
3.组合接口的名字的冲突
package interfaces;
//接口同名会产生冲突 (注意是同名)
//类 和接口 同时 实现和继承时 同名同返回类型会产生冲突
interface I1{
void f();
}
interface I2{
int f(int i);
}
interface I3{
int f();
}
class C{
public int f(){
return 1;
}
}
class C2 implements I1,I2{
public void f(){};
public int f(int i){
return 1;
}
}
class C3 extends C implements I3{
public int f(int i){
return 1;
}
}
class C4 extends C implements I3{
public int f(){
return 1;
}
}
class C5 extends C implements I1{}
interface I4 extends I1,I3 {}
interface里面的东西都会自动加 public +final
interface Months{
int JANURAY = 1,FEBRUAY =2,
MARCH=3 ,APRIL=4,
MAY =5; //自动加public+final
}
7.接口的内嵌,(好凌乱,不太看懂)
class A{
//1.定义(却生子)内部类里面来搞 接口
interface B{
void f();
}
public class BImp implements B{
public void f(){}
}
//定义private class
private class BImp2 implements B{
public void f() {
// TODO 自动生成的方法存
}
}
//public的接口
public interface C{
void f();
}
class CImp implements C{
public void f(){};
}
private class CImp2 implements C{
public void f(){};
}
//私有接口 ,
private interface D{
void f();
}
private class DImp implements D{
public void f(){};
}
public class DImp2 implements D{
public void f(){};
}
public D getD(){
return new DImp2();
}
private D dRef;
public void received (D d){
dRef = d;
dRef .f ();
}
}
//接口E内部类有G
interface E{
interface G{
void f();
}
public interface H{
void f();
}
void g();
// 不可以在接口里面声明私有接口
// private interface I{}
}
public class NestingInterfaces{
public class BImp implements A.B{ //接口里的接口 A.B
public void f(){}
}
class CImp implements A.C{
public void f(){}
}
// 实现不了 private接口
// class DImp implements A.D{
// public void fun(){};
// }
class EImp implements E{
public void g(){}
}
class EGImp implements E.G{
public void f(){}
}
class EImp2 implements E{
public void g(){}
class EG implements E.G{
public void f(){} //在类里面定义类,也可以再 实现非private接口
}
}
public static void main(String[] args) {
A a =new A();
// A.D ad = a.getD(); 私有接口D
//
// A.D ad = a.getD(); 私有接口的D
//
// A.DImp2 di2 = a.getD(); 私有接口D
//
// a.getD.f();
A a2 = new A();
a2.received(a.getD() );
}
}
