2.重写类中equals判断是否两个类中某一个值相同那么两个类的equals就返回true
public boolean equals(Object b)
{
if(this==b)
return true;
if(this.getClass()==b.getClass()&&b!=null)
{ person a=(person)b;/*因为传进去的是object，假如不强制转换类，电脑编写这段时会默认错误；
if(a.get().equals(this.get()))
return true;
}
return false;
}
3.class person()/*单例类，只能有一个实例，第二个将会返回同一个对象，
{
private static person instance；
private person()/*将构造器封装起来*/
public person getperson()
{
if(instance==null)
{
instance=new person();
}
return instance;/*如果instance已满，那么就不让调用构造器*/
}
}
4final 修饰的 一旦被赋予初始值，那么就不可以改变
几个问题
（1）成员变量一般是默认赋值的，那么“final int a；”不可改变了？
final修饰的成员变量必须显示赋值！！！
（2）修饰引用变量？
数组：其中的内容可以改变，不可改变的是栈指向的对象，也就是“线”这个联系不能改变
string：首先看string的源码 private final char value[];本身就不可改变
（3）宏替换final；
如何使第二个返回true；
string a="暴走" 1
string b="颂歌" 2
string c="暴走"+"颂歌"
string d=a+b
string e="暴走颂歌"
e==c
d==c
第一个返回true，第二个返回false
因为编译时直接这种常量的操作会直接进行（常量池），从而e和c会同时返回常量池的“暴走颂歌”对象
1，2若都加上final修饰，进行了宏替换，就会返回true
5final方法不允许子类进行改写 比如object类的getclass（），而final类不可以有子类
6不可变类有一个要点，就是当一个不可变类运用组合时，会传入另一个可变类当初始值，体会下面的语句
public person（Name name）
{
this.name=name;
}
public person(Name name)
{
this.name=new Name(get(),get());
}
这样就改变传入name的成员变量情况下，不会影响person中的成员变量name
那么，可能会有以下疑问
person这样设置会有用吗？
private final Name name；
引用变量不准改变，指的是对象的唯一性；
7第七个知识点 缓存实例的不可变类
为什么多是不可变类需要缓存实例？
因为不可变量的实例不可改变，所以一般会被多个对象共享，所以假如有相同的则用缓存即可
那么代码其实与单例类有异曲同工之妙
class cach
{
private static MAX=10;/*很常见的为什么要设一个变量，答改变这个变量以后的10都会自动改变，
C语言中宏替换也是这个原理*/
private static cach[] huancun=new cach[MAX];
private static pos=0;/*记录缓存有几个*/
private string name;
public string name
{
return name;
}
private cach(string name)/*将构造器隐藏起来*/
{
this.name=name;
}
public cach getcach(string name)/*在缓存中查询是否创建了，没创建就创建一个，并且存进去，满的话就
存入第一个，把pos调成1*/
{
for(int i=0;i<pos;i++)
{
if(huancun[i].getname().equals(name))
{
return huancun[i];
}
}
if(pos!=MAX(不是 10))/*注意我这点就直接写错了，不应该是10，而是max*/
{
cath[pos++]=new cach(name);
return cach[pos-1];
}
else
{
cath[0]=new cach(name);
pos=1;-
return cath[0];
｝
}
}
public interface output
{
int MAX=50;(接口类的成员变量默认是使用public static final修饰的，因此另一个类即使处于不同的包下，也可以通过接口来访问成员变量 )
void out();
void getDate(string msg);
default void print(string...msgs)
{
for(string msg::msgs)
{
syso(msg);
}
}
default void test()
}（接口支持多继承，接口之间相互继承，用关键字extends
类使用接口是implements）
关于抽象类与接口的区别
目前我的理解是
抽象类是对于类的性质的一个概括
而接口是对于其他类的一个“契约关系”，使用这个接口？
接下来使用一个类使用out接口，使用product接口（想一想为什么用着个）
interface product
{
int getproducetime();
}
class printer implements out(实际上不止out这一说，是从外界获取数据存到类上加将打印),product
{
private string[] data=new string[MAX];
private int datenum=0;
void getdate(string msg)
｛
if(datenum>=MAX)
{
syso("队列满了")；
｝
else
{
data[datenum++]=msg;
}
}
void out()
{
for(int i=0;i<=datenum;i++)/*while(datenum>0)
{
syso(data[0]);
system.arraycopy(printdata,1,printdata,0)
datanum--;
system.arraycopy复制数组 +
接口要求了使用他的类
}
{
syso("data[i]")
}
}
}
简单工厂模式
+
class computer/*需要组合一个输出设备，那么组个接口（在实现工厂里将接口与输出类调整一起）*/
{
private output out;
computer(output out)
{
this.out=out;
}
/*因为是组合所以要定模拟的方法：模拟获取字符串的方法，模拟打印的方法*/
void print()
{
out.out();
}
public void keyin(string msg)
{
out.getdata();
}
}
/*工厂区，*/
class outputfactory
{
public getoutput()
{
return new printer;
}
public static void main(string[] args)
{
outputfactory of=new outputfactory();
computer t=new computer(of.getouput());
c.keyin("说实话我想买那个电动牙刷")
}
}/*当想换成betterprint时，只要betterprint连上out接口，return new betterprinter即可*/
/*目的现在仍然说实话不清楚，但了解的是实现的原理，接口这东西一旦与一个类联系起来，就像一个召唤契约一样，首先你类要按我的规范来，好了你上了我的契约，但上面不止一个，看使用契约的人想用哪个。就如上一个简单工厂模式，其printer接上了out接口，并且在out接口的规范下，实现了自己本身的方法。但在实现类其实一直操作的是out，computer组合的也是out接口，只不过有一条语句耦合了printer，可以轻松换成betterprinter。*/
class printcommand implements command
{
public process(int[] target)
{
for(int tmp::target)
{
syso("tmp");
}
}
}
class addcommand implements command
{
public process(int[] target)
{
int sum=0;
for(int tmp::target)
{
sum+=tmp;
}
}
}
interface command
{
void process(int[] msg);
}
/*上面分析的知识只能用到此了，接下来要实际分析，在实现类要体现选择，但接口无法创建实例，所以要将接口再接上一个类，一个设置选择（实际在static main
那里选择）的类*/
class xuanze
{
public process(int[] target,command cmd)
{
cmd.process(target)
}
public static void main(string[] args)
{
}
}
/*实际分析这个，command这个接口里有process这个方法，addcommand与printcommand分别连上command（与command定了契约，实现契约所规定的process方法，从此command就可以代表这两个类，但实际编程中还需要“一个选择”的类，目前已经见到两种写法）
class xuanze
{
public out getout()
{
return new printer();
}
}
其实我感觉这些知识可以都这样概括 目的 用法，而我的学习过程可以是将这些复述出来
内部类
目的：我在前面的知识学了组合，与继承，那么思考这样一个事例，有一个羊类，和一个羊腿的类，组合和继承合适吗？不合适。因为羊腿只对羊类有意义提供内部类，羊腿类定义在羊内，羊所有的成员变量对羊腿开放，但外部类不能访问内部类的实现细节，例如成员变量。那么怎么使用呢，在外部类创建对象从而使用，当然这也是有条件的
外部类 其他类
public √ √
private √ ×
同一包下 非同一包下 外部类子类
protected √ √ × √
省略 √ √ × ×
class out
{
class in
{
public in(string msg)
{
syso(msg);
}
}
}
class test
{
public static void main(string[] msgs)
{
out.in it=new out().new in("a");
}
}
外部类以外使用静态内部类
目的：不知。。。。
细节：class out
{
static class in
{
public in(string msg)
{
syso(msg);
}
}
}
class test
{
public static void main(string[] msgs)
{
out.in in=out.new in("一次就好")；
}
}
由上面可见其静态内部类和非静态内部类声明语法是一样的，不同的是在创建内部类对象时，非静态需要调用外部类构造器再调用内部类构造器
静态类这不需要；对比：
out.in in=new out().new in();
out in in=new out.in();
匿名内部类
目的：只需使用一次的类 自己的理解：想使用接口或抽象类，想直接使用，就用一次就够了
interface product
{
public void getdate(string msg);
}
class number
{
public number(product p,msg)/*它打开了product这个契约，谨慎审视着上面的名字，要用那个呢？*/
{
p.getdate(msg);
}
}
class test
{
public static void main(string[] msgs)
{
number b=new number(new product(){
public void getdate(string msg)
{ syso(msg); }
}/*不想再把product联系，我就直接利用契约创建一个对象，直接把契约当普通的类使用，后面加一个花括号解释就行。*/,"或许能行"）
)
product f=new product（）{
public void getdate(string msg)
{ syso("为所欲为"）； }
/*这次就把接口当成普通类去创建对象，用花括号解释一下就可以了*/
}
}
今天喜欢的歌：看图片也可以猜出是洛天依的《权御天下》
书：房思琪的初恋乐园，一本悲伤的书，尤其了解了作者的后来事情。。。更难受了。今天没时间再写了，明日再写看这本书感受