JAVA的一些笔记

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
/*一般函数与构造函数的区别
构造函数:对象创建时,就会调用与之对应的构造函数,对对象进行初始化
一般函数:对象创建时,需要函数功能时才调用
 
 
构造函数:一个对象对象创建时,只调用一次
一般函数:对象创建时,可以被调用很多次
*/
 
 
/*当成员变量和局部变量重名时。可以用this来区分
this:代表对象。 代表那个对象?当前对象
this就是所在函数所属对象的引用
简单的说:那个对象调用了this所在的函数,this就代表那个对象
    this也可以用于在构造函数中调用其他构造函数
   注意:只能定义在构造函数的第一行。因为初始化函数要先执行
    
public Demo(String name,int age)
{
    this.name=name;
    this.age=age;
}
public boolean bijiao(Demo p)
{
    return this.age=p.age;
}
pyblic static void main(String[] args)
{
Demo p1=new Demo("超霸",18);
Demo p2=new Demo("暮雪",20);
    p1.bijiao(p2);
}
 
*/
 
/*,String name ///成员变量,实例变量
 
static String name //静态变量,类变量
 
成员变量and静态变量的区别?
1,两个变量的生命周期不同
成员变量随着对象的创建而存在,随着对象被回收而释放
静态变量随着类的加载而存在,随着类的消失而消失
2,调用方式不同
成员变量只能被对象调用
静态变量可以被对象调用,还可以被类名调用
3,数据存储位置不同
成员变量数据存储在堆内存中,所以也叫对象的特有数据
静态变量存储在方法区的静态区,所以也叫对象的共享数据
*/
 
/*静态使用的注意事项
1,静态方法只能访问静态成员。(非静态既可以访问静态,又可以访问非静态)
2,静态方法中不可以使用this或者super关键字
3.主函数是静态的
静态在方法区的静态区,栈内
4.静态什么时候用?
1静态变量
 
2.静态方法
*/
1
 
/*extends继承 implements接口继承   public class 类名 implements 接口A,接口B{类体}
public interface 接口a extends 接口B{
    常量定义   方法声明
}
class 子类 extends 父类
 
*/
class Person
{
    String name;
int age;
}
 
class Student extends Person
{
//String name;
//int age;
void study()
    {
    System.out.println("good good student study");
}
}
 
 
/*abstract 抽象类and接口
abstract class 类名{{类体}
abstract void show();
抽象类:笼统,模糊,看不清。不具体
特点
1.方法只有声明没有实现时。该方法就是抽象方法。需要被abstract
抽象方法必须定义在抽象类中
2.抽象类不可以被实例化,为什么?因为调用抽象方法没意义
3.抽象类必须有其子类覆盖了所有的抽象方法后,该子类才可以实例化
否则,这个子类还是抽象类。
 
1.抽象类中有构造函数吗
有。用于给子类对象进行初始化
2.抽象类可以不定义抽象方法吗?
可以的。但是很少见,目的就是不让该类创建对象。AWT的适配器对象就是这种类
通过这个类中的方法有方法体。但是却没有内容
abstract  class Demo{
    void show1()
    {}
    void show2()
    {}
}
3.抽象函数不可以和那些关键字共存?
************抽象方法要被覆盖
private 不行
static 不行  静态无法被覆盖  静态不需要对象。无意义
final 不行。。最终的,无法被覆盖
4.抽象类和一般类的区别
相同点:
      抽象类和一般类都是用来描述事物的。都在内部定了成员
      不同:
      1.一般类有足够的信息描述事物
      抽象类描述的信息有可能不足。
      2.一般类中不能定义抽象方法。只能定义非抽象方法
      抽象类中可定义抽象方法。同时科院定义非抽象方法
      3.一般类可以被实例化
      抽象类不可以被实例化
5.抽象类一定是个父类吗?
是的。因为需要子类覆盖其方法后才可以对子类实例化
 
 
定义接口关键字 
interface Demo
{   常量定义   方法声明
    abstract void show1();
}
对于接口中的常见的成员,而且这些成员都有固定的修饰符
全局常量 public static  final
抽象方法 public abstract
接口中的成员都是公共权限
interface 类名{
接口的定义
类与类之间是继承关系 类与接口直接是实现关系
接口不可以实例化
只能由实现了接口的子类并覆盖了接口中所有的抽象方法后,该子类才可以实例化
否则这个子类就是一个抽象类
}
 
抽象类和接口的异同点
不同点:1.抽象类需要被继承,而且只能单继承
接口需要被实现。而且是多实现。
2.抽象类中可以定义抽象方法和非抽象方法,子类继承后,可以直接使用非抽象方法。
接口中只能定义抽象方法,必须由子类去实现
3.抽象类的继承是is a关系,在定义该体系的基本共性内容
接口的实现是like a关系,在定义体系额外功能。
*/
 
 
/*对象的多态性
 
class 动物
{}
class 猫 extends 动物
{}
class 狗 extends 动物
{}
猫 x= new 猫();
动物 X=new 猫();  一个对象。2中形态
猫这类事物即具备猫的形态,又具备着动物的形态。这就是对象的多态性
简单说:就是一个对象对应着不同类型
 
 
多态在代码中的体现
父类或者接口的引用指向其子类的对象
 
 
 
 
 
*/
 
 
/*内存的划分
 
1寄存器
2本地方法区
3方法区
4栈内存
    存储的都是局部变量,局部变量一结束就消失
    变量一旦离开作用域一旦结束。改变量就自动释放
    生命周期短,更新快
5堆内存
 
存储的是数组和对象(其实数组就是对象),凡是new建立的都在堆中。
实体用来封装存储对象多个数据。
堆特点
1.每个实体都有首地址
2.堆内存中没一个变量都有默认初始化值,根据类型的不同而不同
3.垃圾回收机制
 
 
 
 
 
public class CalcDemo1 {
    public static void main(String[] args) {
        for(int x=0;x<5;x++)
        {
             
        }
        System.out.println(x);
    }
}
 
 
*/
 
 
/*设计模式
对问题行之有效的解决方式。其实它是一中思想
单例设计模式
解决的问题:就是可以保证一个类在内存中的对象唯一性
如:对于多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性
如何保证对象唯一性?
1.不允许其他程序用new创建该类对象。
2.在该类创建一个本类实例
3.对外提供一个方法让其他程序可以获取该对象
步骤
私有化该类构造函数
通过new在本类中创建一个本类对象
定义一个公有方法,讲创建的对象返回
*/
 
/*单列设计模式。保证对象唯一性
 
 
 
class  SingleDemo
{
    public static void main(String[] args)
    {
 
    Singel t1=Singel.getInstance();
Singel t2=Singel.getInstance();
t1.setNum(10);
t2.setNum(20);
System.out.println(t1.getNum());
System.out.println(t2.getNum());
    }
}
对象唯一性实现方法
class Singel  //饿汉式  类一加载。对象就已经存在了。。一般用这个
{
    private int num;
    private static Singel s=new Singel();
    private Singel(){}
    public static Singel getInstance()
    {
        return s;
    }
public void setNum(int num)
{
    this.num=num;
}
public int getNum()
    {
return num;}
}
 
class Singel2  //类加载进来,没有对象。只有调用get方法时,才会创建对象  懒汉式
{
    private static Singel2 s=null;
    private Singe12(){}
    public static Singel2 getinfo()
    {
        if(s==null)
            s=new Singel2();
        return s;
    }
 
}
 
*/
 
 
/*Thread多线程  继承   重写run方法。代码放在run中   start启动线程并调用run方法
 
 
*/

  

posted @   暮雪超霸  阅读(213)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示