寒假学习java笔记

Day1 2020年1月21日

1.一行最好只定义一个变量，定义多个变量要每个都赋初值

2.浮点输入：（声明用Double/Float，利用in.nextDouble()/in.nextFloat()输入）

浮点计算：只要运算符两边有一个浮点就按浮点计算，否则结果保留整数

浮点比较： 判断a==b? 使用 Math.abs(a-b)<1e-6

3.运算符优先级

单目运算符优先级最高，（int）就是单目运算符 ，再如：–、++

关系运算符优先级 < 加减

关系运算

==和!=优先级比其他的低

6>5>4(错了，这样是true>4)

4.if-else

可以If-else if -else级连

最好是单一出口（在级连之中赋值，级连结尾后输出）

常见错误：

（1）忘了大括号（所以每次写if都加一个大括号）

（2）If后面加了分号，变成加了空语句

（3）If(a=b) (X) if的括号里的东西必须是boolen型

Day2

一、逻辑类型

1. 只有两种值 true 或者false

2. 类似的声明：Boolean isprime=true;. 或者 Boolean tooHigh;.

3. 优先级顺序： ! && ||

二、数组

1. 声明方式①<类型>[]<名字> = new<类型>[元素个数]

2. 声明：int[] numbers = new int[100];

3. 元素个数必须给出

4. 元素个数可以是变量（但是一旦初始化完成后，变量改变，数组元素个数不会改变）

   int num=5;
   int i;
   int[]a=new int[num];
   num=7;
   for (i=0;i<num;i++)
   {
          
     a[i]=i;
   }
   

   这样会溢出，因为a的大小初始值是5，num变为7，a的长度不会变。

5. 数组长度=数组名字.length

6. 声明方式②：试试 int[] numbers = {1,2,3,4,5}；

7. 数组变量是管理者！（普通的变量是所有者）

   Eg. int[] a = new int[100];
   
   int[]b=a;
   
   // a==b 是true
   

让b有权限管a所管理的那个数组，所以a,b同时管理 一个数组。

8.深度拷贝（让a,b管理不同区域，但是b的初始内容与a相同）

int[] copy=new int[numbers.length];
for (i=0;i<copy.length;i++)
{
     
  copy[i]=numbers[i];
}

for each循环

①（只是取出数组元素，但是不知道它是第几个）

② 浅拷贝 修改k,numbers不会变

③ 格式 for(int k : numbers );

9.二维数组

声明：①int[][]a = new int[行数][列数];

②Int[][]a={

{1,2,3},

{1,2},

};

每行一个{}，逗号分隔

最后的逗号可以存在

Day3

一、字符串

1. char型定义：一个字符；

2. 包裹类型：

①int --> Integer 有 .MAXVALUE;

②char–>Character 有.isdigit() .isupper()等类方法；

3. Math类

①abs 绝对值 ③random 随机数

②round 四舍五入 ④pow 幂运算

4. 字符串

（1）String是一个类，String变量是对象的管理者，而非所有者

（2） 创建： String s = new String(“a string“);

（3） 创建： String s = “hello”;

（4） 运算： “+”： 从左到右， 拼接

（5） 输入: in.next() :读入一个单词 in,nextLine():读入一行

（6） 判断字符串变量 是否 具有相同的内容： a.equals(b);

（7） 判断字符串变量 是否 指向同一个区域： a==b

（8） S1.compareTo(S2) 类似于c语言strcmp(S1,S2);

（9） S.length() 获得S的长度

（10） S.charAt(index) 获得[0.lemth-1]范围内的index位置的字符

（11）S.substring() 取子串 ；

① S.substring(begin,end) 取 [begin,end) 范围的字符串

② S.substring(index) index 位置往后的字符串；

（12）s.indexOf（）

① S.indexOf( c ) 若 c不存在，返回-1

② 若存在，返回第一个c出现的位置

③ S.indexOf( c ，n)从n 位置开始往右边找c,可以包括n 位置上的c

④ S.indexOf( subs) 可以找子串

⑤ S.lastIndexOf© 从右边往左边开始找c

（13）其他

① S.trim()删除字符串的头尾空白符。

② S.replace(c1,c2) 把s中所有的c1换成c2

③ S.toLowerCase

(14) 字符串是不可变类型，S.toLowerCase不会改变S本身，而是制造了一个新的字符串

(15) Switch-case可以使用字符串作为分支入口

二、函数

1. 方法=函数（一样的称谓）

2. 变量的定义

(1) 本地变量是定义在函数的块内(大括号)的

(2) 也可以定义在语句的块内，甚至可以随便拉一对大括号，在其中定义变量

(3) 不能在一个块内定义同名的变量，也不可以定义块外面定义过的变量

(4) 程序运行进入到这个块之前，其中的变量不存在，离开这个块，其中的变量就消失了

Day4

一、对象

１．构造函数

(1) 构造函数没有返回类型

(2) 重载：一个类可以有多个构造函数，根据参数自动调用

２．Private

(1) 只有　成员变量　和　成员方法　可以被private修饰

(2) Private变量只可以被　类的成员函数访问

public void changeTo(Display d) {
     
  this.value = d.value;
}

(3) 例子如　↑　　　在Display类内部定义的changeTo方法，可以直接访问d的私有成员变量value,因为d也是Display类的对象。

３．Public

(1) 所有不带public 、　private 和 protected 的成员　被称为“friendly”,可以被同一个包下的其他类　访问。

(2) 如果想要被其他包的成员访问，就用public修饰一下。

(3) 一个编译单元（.java文件）只能有一个public类

４．Static

(1) 类变量，一改，全改。　且可以直接访问　　类.变量（eg, Display.step）

(2) 类函数,　表示次函数不属于任何对象，属于类

(3) Static修饰的东西，既可以被类访问，也可以被对象访问。

５．ArrayList

(1) ArrayList声明时候，说ArrayList　ａ= new　ArrayList()这样.

(2) notes.toArray(a) 可以数组a 自动填满

(3) Notes.size　.add .get ,remove 　　四件套

６．对象数组的　每个元素都是对象的管理者　而非对象的所有者，例如String[] a＝new String[10] 只是制造了１０个空的管理者。一般要接着通过for循环创建初始值(调用对象的构造方法)。

Ｅg,

for(i=0;i<10;i++){
     
			a[i]= new String(“”+i);
}

７．HashSet

(1) HashSet声明时候，说Hashset　h= new　Hashset()这样.

(2) hashset里没有重复元素

(3) Hashset和　ArrayList都可以直接println

8．只要在类里面写了　Public String toString(){ return “”+　i（i是成员变量）; }　输出的时候,直接println（对象）就会把成员变量输出为可以读的字符，格式由toString决定。

9．HashMap

(1) HashMap声明时候，说　HashMap　h　= new　HashMap()这样的键值对（Ｋ,V都必须是对象类型，例如Integer,String不可以是int）.

(2) .containsKey(k) :返回true，含有k

(3) .put(k,v)：加入键值对，同一个k放多次v，只保留最后一次,因为键值对是一一对应的。

(4) .keySet() 通过.keySet().size()可以知道HashMap里有多少个key

(5) .get(k) 返回k对应的v

10. StringBuffer

(1) Append

(2) ToString

二、继承

１．可以利用构造器工具，直接写出构造方法（Alt+Insert）

２．父类的private变量只有父类自己可以用

３．父类的protected变量可以由　同一个包里的其他类　以及　不同包里的子类　使用。（尽量不要把父类做成protected,最好用private）

４．Super(pramater) 可以根据参数调用父类的构造器。　super.f()调用父类的方法

５．子类在构造时，会先保证父类的成员变量被合适地初始化

６．子类里如果有与父类当中同名的变量(下称child和father指代子类的同名变量和父类的同名变量)，则子类的方法调用的是child,父类的方法调用的是father.

７．造型　vs　类型转换

(1) 造型　是把类Ａ当做类Ｂ来使用（类Ａ本身的属性不会改变，只是别人看它的方式变化了）

(2) 类型转换　只适用于基本类型，如 (int)、(double)这样的强制类型转换，会改变属性

(3) 所以，子类的对象可以直接赋给父类的变量，父类的对象不可以直接赋给子类的变量

(4) Ｅg .

Velchicle v;

Car c = new Car();

ｖ = c ;  //可以

c = v ; //编译错误 

(5) 父类要赋给子类，需要用造型: c = (Car) v;

(但是只有当v这个变量实际管理的是Car才行,这个（Car）造型　只是给编译器看的)

(6) Java里面所有函数都是动态绑定，编译器会自己找到对象对应的函数

(7) Override：　子类的函数会覆盖父类的同名函数

(8) 高内聚，低耦合

① 类和类之间的关系叫做耦合，耦合越低越好

② 用封装来降低耦合：把成员变量都搞成private

③ 用容器来实现 可扩展性：HashMap　替代　成员变量表示方向（尽可能减少硬编码）

④ 用　框架＋数据　提高可扩展性：

1. 看看命令的解析是否可以脱离if-else

2. 定义一个Handler来处理命令

3. 用Hash表来保存命令和Handler之间的关系

三、抽象

1．抽象函数（有abstract修饰符）：表达概念而不能实现具体代码的函数

2．抽象类：表达概念而不能构造出实体的类

3．抽象函数的类一定是抽象类

4．抽象类不能制造对象，但可以定义变量，非抽象子类的对象可以交付给这个变量

Day5

1.接口

(1) 声明接口　用　public interface cell (它与class是同级的 )

(2) 实现接口　用 implements　cell (它与extends是同级的)

(3) 接口的所有成员函数都是抽象函数，所有成员变量都是public static final|

(4) Eg.

interface A {
     // 定义了接口

	public static final String MSG = "Hello";// 全局常量
// 抽象方法
	public abstract void print();

}

2.内部类

(1) 放在某个类内部，被当做内部成员，可以访问其他成员变量，调用其他成员函数

(2) 放在某个函数内部，可以访问函数所在类的其他成员变量，调用其他成员函数，可以访问所在函数的final本地变量

3.匿名类

(1) 内部类的一种

(2) 在new 对象时，给出的类的定义形成了匿名类

(3) 匿名类可以继承某类，也可以implements

(4) Swing在new　Listener时，会常常用到匿名类（减少取名字的麻烦）

４．MVC设计：View　和 Control　分离，　用户点击由Control部分代码修改数据，View只管拿到数据，repaint()

Day6

一、异常

1．祖传句式

（1）　try{ } catch(…Exception e　){ }catch(…Exception e　){ }catch(…Exception e　){ }(应对多种不同type的异常)

2．异常捕捉机制

（1）有异常 --> 先看所处的代码块是否是try, 是则看是否和catch匹配。否则看所处的函数的调用处是否是try…(翁老师给了一张流程图（>V<)）

（2）e.printStackTrace()可以查看异常源头函数的调用关系

（3）捕捉了异常，则不会打印e,如果还想看看这个e,可以在catch{}里写一个throw e;

3．定义异常

（1）祖传句式

①Class OpenException extends Throwable{}

②Public class f()throws OpenException{}

4．当　异常声明　遇上　继承关系

（1）当覆盖一个函数的时候，子类不能声明抛出比父类的版本更多的异常

（2）在子类的构造函数中，必须声明父类可能抛出的全部异常