java入门笔记

1System.out.println(); 输出
2
3int 整数类型 不能以数字开头 区分大小写
4int a=0  
5int的范围2的31次方到-2的31次方  21亿左右
62个int型运算后仍为int
7除法没有余数14/5=2  
8%模运算 14%5=4 求余数.
9
10
11double 双精度浮点型  比较大非无限
12double c=123.456  double e=-123.456
13浮点型除法保留小数.
14double类型则不能使用双等号来比较大小，如果使用的话得到的结果将永远是不相等
15
16
17
18String s="abcd" 字符串类型
19
20
21变量的赋值= 
22
23布尔类型变量 boolean
24boolean只能为 true 或者 false
25
26ctrl+/ 群体注释
27
28类型的提升 int和double做运算 强制提升int为double;
29
30
31表达式和操作符
32表达式 Expression
33操作符 Operator
34
35关系表达式的值为boolean类型的值;
36==双等号 判断两个变量是否相等
37
38
39类变量：独立于方法之外的变量，用 static 修饰。
40实例变量：独立于方法之外的变量，不过没有 static 修饰。
41局部变量：类的方法中的变量。
42
43逻辑非!   逻辑与&&   逻辑或||
44
45=赋值 a=b 
46
47
48int a=1;//初始化
49a=123;//赋值
50final a =0;
51当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，
52这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变，
53但引用变量所指向的对象中的内容还是可以改变的。
54
55a +=b //a=a+b 
56a -=b //a=a-b
57a *=b//a=a*b
58a/=b //a=a/b
59a %=b//a=a%b
60
61a++自增操作符;
62a++为后置自增　int b=10; a=b++;  //a输出为10,b为11
63++a为前置自增  int b=10; a=++b;  //a输出为11,b为11
64
65优先级与类型转换
66double a=12.77;
67int b=(int)a;//b值为12直接截断小数部分.
68
69单行调试技术
701.加断点 右键 debug as
71
72条件语句 if语句
73if else 
74if{} else if{}
75
76for循环
77for(e1;e2;e3)  e2>>s1>>e3  e2为false跳出循环
78{s1
79}
80
81for循环的嵌套 for循环嵌套if语句
82
83
84break语句和continue语句
85
86break中止当前循环, continue跳出当前轮循环.
87
88
89
90数组对象
91int[] arr=new int[30]// 创建一个数组对象,容纳30个int
92arr[0]第一个元素 arr[29]第30个元素;
93arr[i],i叫索引或者下标. 下标从0开始;
94
95int[] arr={1,2,3,4,5};
96for(int i=0;i<arr.length;i++)
97
98
99数组的遍历
100通过for循环实现遍历.
101int[] a=new int[4];  变量a指向了一个对象
102
103int[] b=a;   //b和a指向了同一个对象  a和b都是该对象的引用,a可以操作目标对象,用b也可以操作目标对象
104
105空对象 null
106null:表示一个引用不指向任何对象
107int[] a={11,11,11,11};
108int[] b=a;
109
110a=null;
111
112空指针错误, 
113int[] a={11,11,11,11};
114a=null;
115a[0]=12;//报错  
116
117失去引用的对象
118int[] a={8,8,8};   //失去引用的对象   
119a=new int[4];
120a[0]=a[1]=a[2]=a[3]=17;
121
122失去引用的对象会被Java环境自动删除.
123
124类的概念
125类,class.一个class可以若干基本类型的组合.
126类Student
127    public String id; //学号
128    
129    public String name; //姓名
130    
131    public boolean sex;//性别
132    
133    public String cellphone;//手机号
134
135Student s1=new Student()
136
137s1.name="XX"
138
1391.类型名Student,  2.属性 学号,姓名,性别,手机号.
140
141类型是描述一类事物的共性,对象是一个具体的实例;
142
143类的嵌套,类的属性可以是另一个类.
144
145
146boolean类型的默认值是false
147
148double类型的默认是null  
149
150
151
152类的方法Method
153public void 方法名() 
154{
155} 
156//修饰符  返回值类型  名称(参数列表)   {方法体}
157调用方法.
158
159
160方法的参数
161参数列表 0-N个参数,以逗号分隔,类型,变量名
162public void sohw(int a,double b,String c)
163
164方法的返回值
165return语句来返回一个值,
166return语句执行后方法不再往下执行.
167
168public int show()
169打印输出只是方便调试结果,
170
171可以在void的返回值时下用return结束函数.
172
173return 的返回值可以是各种类型.
174
175方法名的重载overload
176方法名可以相同只要参数不同就行.
177
178
179第八章当前对象(this)
180this调用当前对象中的
181
182在访问自己的方法时this.可以省略.
183当名字发生重名时不能省略.
184
185public class Triangle
186{
187    public int a;
188    public int b;
189    public String value()
190    {
191        return a+"/"+b;
192    }
193    public Triangle mul(Triangle other)
194    {
195        Triangle c=new Triangle();
196        c.a=this.a*other.a;
197        c.b=this.b*other.b;
198        return c;
199                
200    }
201}
202    时
203        Triangle a=new Triangle();
204        a.a=1;
205        a.b=2;
206        Triangle b=new Triangle();
207        b.a=2;
208        b.b=3;
209        
210        Triangle c=a.mul(b);
211        System.out.println(c.value());
212
213
214第九章 访问修饰符
215public(公开的)该成员可以被外部访问 visible可见
216
217private(私有的)不可访问,not visible不可见 内部访问不受private限制
218
219不写访问修饰符一般为private
220
221
222getter 和setter   读/写  get读  set写    
223getNumber  setNumber
224
225private int number
226
227public int getNumber()
228{
229  return this.number;
230}
231public void setNumber(int number)
232{
233 this.number=number;
234}
235封装
236
237第十章构造方法
238用于构造对象的方法(当创建对象时调用的方法)
239规则1.方法名与类包相同 2.无返回值
240        public String id;
241    public String name;
242    public boolean sex;
243        public Student()
244{
245}
246    public Student(String id,String name,boolean sex)
247{
248    this.id=id;
249    this.name=name;
250    this.sex=sex;}
251
252构造方法可以有多个,一般要加一个默认构造方法即无参数构造方法.
253构造方法一般是public修饰    ,特殊情况用private修饰.
254
255当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
256通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
257不管你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，它把所有成员初始化为0。
258一旦你定义了自己的构造方法，默认构造方法就会失效。
259
260对象的销毁
261只管创建对象,不用销毁对象,对象由系统自动销毁.
262Student s=new Student();
263
264GC垃圾回收机制,回收不被使用的对象.
265
266第11章继承
267public class B extends A 
268{
269}
270继承写在子类的前面.
271表示B继承于A A:父类(supercalss) B:子类(subclass)
272
273类B继承于A时,自动继承A中的public属性/方法.
274
275子类拥有父类非private的属性，方法。
276
277重写
278如果父类的方法不满足要求,则可以在子类重写.
279在子类右键Source 选Override
280
281完全重写和父类基础上补充.
282
283super.xxx();
284
285
286构造方法的继承
287public class Triangle //父类
288{
289    public double a;    
290    public double b;
291    public double c;
292    
293    public Triangle()
294    {
295    }
296    public Triangle(double a,double b,double c) //构造函数
297    {
298        this.a=a;
299        this.b=b;
300        this.c=c;
301    }
302
303public class RightTriangle extends Triangle//子类
304{
305    
306    public RightTriangle(double a,double b,double c) //调用父类的构造函数
307    {
308        super(a,b,c);
309    }
310先调用父类的构造方法,再调用子类的.
311
312多个构造函数 用super(加参数),用的什么参数就调用那个构造方法.
313
314单根继承
315Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，
316多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，
317B类是A类的父类，这是java继承区别于C++继承的一个特性。
318
319右键 Quick Type Hierarchy    
320
321Object类
322Java中Object是所有类的父类  如果一个类没有指定父类,则它默认父类是Object
323
324Object类的toString对象
325    public String toString()
326    {
327        String s="学号"+id+"姓名"+name;
328        if(sex)
329        {
330            s=s+"男";
331        }
332        else
333        {
334            s=s+"女";
335        }
336        return s;
337    }
338
339
340
341多态
342重载Overload  重写Override  泛型.
343
3441.子类和父类的类型转换(隐式转换)
345ApplePie p1=new ApplePile();
346Pie p2=p1;    //类型转换ApplePie->Pie
347
3482.父类转换成子类需要谨慎
349ApplePie p3=(ApplePie)p2;//显式转换
350p2实际指向ApplePie 所以可以转换.
351
352看实际指向对象的具体类型,再调用实际指向对象的具体类型.
353
354所有类型都是Object的直接或间接子类,所以
355Object x=new MyFileVideo(); 没有问题
356
357
358第12章 包
359建包 new package
360包的命名方式xx.xx.xxx  也是包的保存路径xx/xx/xxx
361package xx.xx.xxx 表示本类所在的包的路径
362
363import xx.xx.xxx.*; 一次性导入该包下所有的类
364
365包的显式:Flat 扁平化显示, Hierarchical 层级显示 推荐
366
367eclipse 的快捷操作\
368文件可以拷贝.
369Refresh同步
370包名重复
371
372改名修改包名,类,方法,属性
373选中,右键Refactor rename. 使用到它的地方自动改名.
374保存ctrl+s,注释 Ctrl+/,  Ctrl+鼠标左键 查看定义,
375打开提示 alt+/, 
376
377
378  第13章静态方法.
379该方法没有访问this对象,即没访问this属性,也没访问this方法.
380称为静态方法(全局方法)
381没有上下文单纯的方法.
382
383静态方法用static修饰
384public static boolean isPrime(int n)
385{
386}
387静态方法可以不创建对象
388Xxx a=new Xxx()可以不写.
3892
390Math类:有很多计算静态方法
391abs(a):求绝对值;
392pow(a,b):求a的b次幂
393sqrt(a):求a的平方根
394round(a):四舍五入
395sin/cos/tan:正弦/余弦/正切
396
397程序的入口
398只有main方法可以做为程序得到入口
399
400public static void main(String[] args)
401
402由于是static全局方法,可以放在任意一个类下面.
403main方法的形式是约定好的.
404
405
406单元测试
407写好一个类后 添加一个main方法,对一个类进行测试.
408
409第14章 常见工具类
410
411String 字符串
412String s="人好nihao";    //中文字符和英文字符都占一个字符
413int n=s.length();    //n=7;
414
415空字符串
416String s="";   //空字符串和null是两回事!      空字符串是一个正常的字符串对象,null不指向任何对象.
417
418子串
419String s="人好nihao";
420String sub=s.substring(0,4); //0,1,2,3,不包含4   
421
422substring(beginIndex,endIndex)不含endIndex;
423
424
425判断内容是否相同
426字符串必须使用 equals
427String s1="nihao";
428String s2="nihao";
429if(s1.equals(s2))
430{
431System.out.println("相同");
432}
433
434比较大小:按字典序比较 s1.compareTo(s2)<0    忽略大小写的比较用compareToIgnoreCase
435String s1="abcd";
436String s2="acef";
437if(s1.compareTo(s2)<0)
438System.out.println(s1+"位于前面");
439else
440System.out.println(s2+"位于前面");
441
442
443格式化
444String s=String.format("姓名:%s,年龄:%d,身高:%.2f","名字",35,1.75);
445String.format()是一个静态方法
446格式化时 %s对应字符串  %d整数  %.2f表示显示2位小数
447
448
449查找 indexOf
450如果有这个子串,则返回位置索引;否则返回-1;
451String c="China is a great country";
452int pos=s.indexOf("great");
453if(pos<0)
454{
455System.out.println("没找到");
456}
457//查询s1中我出现的次数
458        String s1="对角线我,我阿达,我,阿萨德";
459        int count=0;
460        int start=0;
461        while(start<s1.length())
462        {
463            int pos=s1.indexOf("我",start);    //indexOf 查找的字符类型,加开始查询的地址参数.
464            if(pos<0)
465                break;
466            count+=1;
467            start=pos+1;
468        }
469        System.out.println(count);
470
471前缀后缀
472startsWith()  判断前缀
473endsWith()  判断后缀
474
475String d="country.mp4";
476if(d.endsWith(mp4))
477{
478System.out.println("是mp4格式");
479}
480
481基本类型与包装类型
482long<=>Long
483int<=>Integer
484short<=>Short
485byte<=>Byte
486double<=>Double
487float<=>Float
488boolean<=>Boolean
489
490int a=10;
491Integer b = new Interger(10);
492
493    Integer a=new Integer(10);
494    int b=a.intValue();
495    System.out.println(b);
496    
497    Integer k=123;
498    int m=k;
499    System.out.println(m);
500
501
502数值<=>String
503int->String
504String a="123"
505int b=Integer.valueOf(a);  //a
506
507String->int
508String s=String.valueOf(339);
509
510包装类的作用
511提供转换方法,把所有类型统一到类的范畴,都是Object的子类.
512
513控制台Console
514控制台在正式开发中不会用到.
515用于语法练习,模拟用户交互.  //语法,逻辑
516
517随机数的使用
518Random类JDK自带的基本类
519java.util.Random
520
521import java.util.Random;
522Random rand=new Random();
523for(int i=0;i<3;i++)
524{
525int s=rand.nextInt(1000);
526System.out.println("生成随机数"+s);
527}
528
529不允许重复的情况
530
531char类型  字符类型
532char c1 ='A';
533
534字符的编码
535char c1 ='A';
536int n =c;
537System.out.println("生成编码"+n);
538
539A为65,B 66 ,a 97,b 98, 0为48.  空格 为32.
5400-128之间称为ASCII码(仅有英文数字,符号)
541
542字符串和字符
543String=>char
544String str="afanihao"
545char ch=str.charAt(8);  //下标从0开始计算
546char[] chs=str.toCharArray();
547
548char=>String
549char[] chs={"啊","你","好"};
550String str=new String(chs,0,2);
551str+='的';    
552
553第15章链表
554容器:存储对象的东西
555容器是设计术语,非语法概念.
556比如数组就是一个容器.
557
558数组容器的确定,容量固定,无法扩展
559插入和删除困难,插入对象的代价太多,需挪动现有对象.
560
561
56215.2  链表(Linked List)  链表是一种组织数据的方式,可以把若干对象串联起来.
563public class Monkey
564public Monkey next;
565Monkey m1=new Monkey(101,"XX")
566Monkey m2=new Monkey(102,"XX")
567Monkey m3=new Monkey(103,"XX")
568Monkey m4=new Monkey(104,"XX")
569m1.next=m2;
570m2.next=m3;
571m3.next=m4;
572m4.next=null;
573
574以链状形式串起来的.最前面的为链表头.
575节点Node;
576
577链表的遍历
578Monkey node=m1;       //知道头节点的位置.
579while(node!=null)     //当节点不指向空时
580{
581System.out.println("链表"+node);   //输出
582node=node.next;            //指向下一个节点
583}
584
58515.3
586链表插入与删除节点.
5871.附加到末尾
588Monkey m1=new Monkey(101,"XX")
589Monkey m2=new Monkey(102,"XX")
590Monkey m3=new Monkey(103,"XX")
591Monkey m4=new Monkey(104,"XX")
592m1.next=m2;
593m2.next=m3;
594m3.next=m4;
595m4.next=null;
596
597//找到链表的最后一个节点
598        Monkey tail=m1;
599        while(tail!=null)
600        {
601            if(tail.next==null)
602            {
603                break;
604            }
605            else
606            {
607                tail=tail.next;
608            }
609        }
610        tail.next=m5;
611
6122.插入第一位置之后
613
614Monkey hard=m1;
615m5.next=m1.next;  //m5的尾部指向m1的尾部;
616m1.next=m5;       //m1的尾部指向m5;
617 
618
6193.插入指定位置
620插到102之后
621        Monkey head = m1;
622        while (head != null)
623        {
624            if (head.id == 102)
625            {
626                m5.next = head.next;
627                head.next = m5;
628                break;
629            }
630            else
631            {
632                head = head.next;
633            }
634        }
635
636删除节点.
637m1.next=m3; //删除m2;
638
63915.4
640有头链表;
641用一个固定的假节点充当头节点.此节点不算做链表长度,简化算法.
642
643Monkey m1=new Monkey(101,"XX")
644Monkey m2=new Monkey(102,"XX")
645Monkey m3=new Monkey(103,"XX")
646Monkey m4=new Monkey(104,"XX")
647m1.next=m2;
648m2.next=m3;
649m3.next=m4;
650m4.next=null;
651Monkey head=new Monkey(0,"XX");
652head.next=m1;
653
654遍历
655Monkey m=head.next;
656while(m!=null)
657{
658System.out.println("链表"+m);
659m=m.next
660}
661
662插入节点
663插入在头部
664Monkey m5=new Monkey(105,"XX");
665    m5.next=head.next;    //插入节点时 先定义需要插入节点的尾部,
666    head.next=m5;         //插入节点时 再定义需要插入节点的头部.
667//插入在尾部
668Monkey node1 = head;
669        while(node1!=null)   //找到最后位置.
670        {
671            if(node1.next==null)  
672            {
673                break;
674            }
675            else
676            {
677                node1=node1.next;
678            }
679        }
680        m5.next=null;
681        node1.next=m5;
682
683
684
685删除节点
686        Student a=new Student("101","A");
687        Student b=new Student("102","B");
688        Student c=new Student("103","C");
689        Student d=new Student("104","D");
690        Student head=new Student("0","head");
691        
692        head.next=a;
693        a.next=b;
694        b.next=c;
695        c.next=d;
696        d.next=null;
697        
698//删除节点
6991.        Student n=head.next; 101 
700        Student p=head;
701        while(n!=null)
702        {
703            if(n.id=="102")
704            {
705                p.next=n.next;
706                break;
707            }
708            p=p.next;
709            n=n.next;
710        }
711
712//删除节点
7132.        Student node=head;
714        while(node.next!=null)
715        {
716            if(node.next.id=="102")             //判断是否是要删除的节点
717            {
718                node.next=node.next.next;   //实现删除节点
719                break;
720            }
721            node=node.next;                     //往下个节点走.
722
723        }
724
725//遍历
726        Student i=head.next;
727        while(i!=null)
728        {
729            System.out.println("链表为"+i);
730            i=i.next;
731        }
732
733链表和容器
734XXXList
735黑盒,容器是不透明的,不需要关心它是如何内部存储对象的.
736
737public class Monkey    //定义monkey类
738
739{
740    public int id;
741    public String name;
742    public Monkey next;
743    
744    public Monkey()
745    {
746        
747    }
748    public Monkey(int id,String name)
749    {
750        this.id=id;
751        this.name=name;
752        
753    }
754    @Override
755    public String toString()
756    {
757        
758        return String.format("id:%d, 名字:%s",id,name);
759    }
760
761
762    
763
764}
765
766public class MonkeyList      //链表存储实现容器
767{
768    
769    Monkey head=new Monkey(0,"石猴");
770    
771    //添加对象
772    public void add(Monkey m)
773    {
774        m.next=head.next;
775        head.next=m;
776        
777    }
778    
779    //编号查找
780    public Monkey get(int id)
781    {
782        Monkey node = head.next;
783        while (node != null)
784        {
785            if(node.id==id)
786            {
787                return node;
788            }
789            node = node.next;
790        }
791        return null;
792    }
793
794}
795
796    MonkeyList lst=new MonkeyList();    //主函数
797        
798    Monkey m1 = new Monkey(100, "圆圆");
799    Monkey m2 = new Monkey(101, "芳芳");
800    Monkey m3 = new Monkey(102, "谢谢");
801    Monkey m4 = new Monkey(103, "哦哦");
802    Monkey m5 = new Monkey(104, "最后添加的");
803
804
805    lst.add(m1);                   //实现添加
806    lst.add(m2);
807    lst.add(m3);
808    lst.add(m4);
809
810    Monkey a=lst.get(102);          //查找的实现
811    if(a!=null)
812    {
813        System.out.println("找到了"+a);
814    }
815
816
817
818数组链表ArrayList
819import java.util.ArrayList;
820
821                Student a=new Student("101","A");
822        Student b=new Student("102","B");
823        Student c=new Student("103","C");
824        Student d=new Student("104","D");
825        
826        ArrayList x=new ArrayList();
827        
828        x.add(a);
829        x.add(b);
830        x.add(c);
831        x.add(d);
832        
833        for(int i=0;i<x.size();i++)
834        {
835            Student s=(Student)x.get(i);
836            System.out.println("遍历得到"+s);
837        }
838
839
840删除 x.remove(1)    //索引