1、读输入
Scanner in=new Scanner(System.in);//in这个对象做读入下一行的操作
System.out.println(in.nextLine());//System.out这个对象打印下一行2、数组
其中所有的元素都具有相同的数据类型int []s=new int[maxn];//数组定义 new创建的数组会得到默认的0值 创建maxn个int型数组
int []s={1,2,3,4};//直接初始化数组 可以不用给出大小 有成员函数length可直接使用
数组变量是 ！**数组的管理者**！而非数组本身！
数组必须创建出来交给数组变量管理，数组变量之间的赋值是**管理权限**的赋予，
数组变量之间的比较是判断**是否管理同一个数组**
eg. s是有maxn个元素的数组的管理者
3、包裹类型
基础类型 包裹类型
boolean Boolean
char Character
int integer
double Double可以通过包裹类型获取该类型的最大最小值，判断是否是字母什么的 可以有更多的功能扩展
4、Math类
Math.abs(-12);//12
Math.pow(2,3);//8.0 浮点运算
Math.random();//生成0~1之间的随机数 可以*100 获取0~100之间的随机数
Math.round();//四舍五入
5、字符串
字符串变量并不存放字符串，也不是字符串所有者，它是**字符串的管理者**
Java的字符串是”不可变“对象，所有对字符串的操作都是产生一个新的字符串，
而不是对原来的字符串进行修改
String的变量是对象的管理者
eg. String s=new String("a string");//创建了一个String的对象，并初始化
//创建了这个对象的管理者s 让s管理这个对象
输入字符串，in.next；//读入一个单词,以空格为界 in.nextLine();读入一整行
字符串的比较:
if(input=="bye") 比较的是 是否指向的是同一个String对象 很大可能return false
因为input和"bye"是两个不同的字符串
if（input.equals("bye") 才是比较内容是否相同
对字符串的操作：
s.charAt(index);//返回在index上的单个字符 0~length()-1
//注意 不能用for-each循环来遍历字符串 for(char c:s){}不行
//for-each只适合于数组或者可枚举类型
s.substring(n);//得到从n号位置到末尾的全部内容
s.substring(b,e);//b号位置到e号位置之前的内容 左闭右开
s.indexOf(c);//得到c字符所在位置，-1表示不存在
s.indexOf(c,n);//从n号位置开始找
s.indexOf(t);//找到字符串t所在位置 返回值为子串开始的index
s.lastIndexOf();//从右边开始找
eg.要找一个串中的第二个3 String s="0123453";
int loc=s.indexOf('3');
s.indexOf('3',loc+1);
s.startsWith(t);//s是否是以字符串t开头的
s.endsWith(t);
s.trim();//把字符串两端的空格删掉
s.replace(c1,c2);//所有的c1换成c2
s.toLowerCase();//所有字符都变成小写
s.toUpperCase();
6、 本地变量不会被自动初始化 有可能会报错，所以要记得初始化
本地变量：定义在函数内部,作用域和生存期都在函数内部，
而成员变量（自动初始化为0或null）的生存期是对象的生存期，作用域是类内部的成员函数
7、类和对象
VendingMachine v=new VendingMachine();//对象变量是对象的管理者
v.insertMoney()中使用的成员变量是v的成员变量实际上**是通过this实现的**this:
this是成员函数的一个特殊的固有的**本地变量**，它表达了调用这个函数的 **那个对象**
在成员函数内部直接调用自己的其他函数，也可以通过this来实现(通常会省略）一个类的成员变量可以是其他类的对象
8、封装：把数据和对数据的操作放在一起，并且用这些操作把数据掩盖起来 （面向对象核心概念）
直接手段：
类的所有成员变量必须是private的
所有的public的函数，只是用来实现这个类对象或类自己要提供的服务的，而不是用来直接访问数据。private（类所私有的）只能用于成员变量和成员函数:
public class Display{
private int num;
private int getValue(){ };//不可以在getValue函数中定义变量的时候使用private
}注意：
- 只有这个 类内部（类的成员函数和定义初始化） 可以访问
- 这个限制是对类的，而不是对对象的
//private定义的变量，限制其他类的对象访问本类对象的这个变量，但不限制本类的其他对象访问奔雷的private数据
public class Fraction{
private int a;
private int b;
public Fraction plus(Fraction r)
{
int fenzi=a*r.b+r.a*b;//这个完全可以实现哦，因为private的限制不是对对象的，他们都在Fraction类里
int fenmu=b*r.b;
return new Fraction(fenzi,fenmu);
}
}9、包
10、类变量和类函数
- 类是描述，对象是实体
- 在类中所描述的成员变量，实际上是位于这个类的各自的对象中的
- 但是如果某个成员由static关键字修饰，它就变成了属于整个类的了
- 每个对象都可以访问到这些类变量和类函数并且可以直接通过名字调用
- 类函数不属于任何对象，无法建立与调用他们的对象的关系，也就不能直接访问任何非static的成员变量和成员函数,必须要通过对象进行调用
- this表示当前本对象，类函数和对象没有任何关系，所以类函数没有this
- 通过一个类的对象对static变量进行了修改，那么其他对象中的这个变量的值也都被修改了，因为这个变量是类的，而不是单独某一个对象的
- 可以通过 类.static型变量 对该变量进行访问
- static变量只能被初始化一次,在第一次类的装载的时候被初始化
11、对象容器
究竟把什么放进容器里了？对象的管理者.
泛型类：eg. ArrayList 这种泛型类是一种容器
无限放东西，计算机有容量就能一直放，数组无法实现，要用容器实现
容器类有两个类型：容器的类型（ArrayList）、元素的类型（String)
import java,util.ArrayList;
public class NoteBook{
private ArrayList<String> notes=new ArrayList<String> ();
//ArrayList类中常用成员函数
//notes.add(s); notes(location,s);//把s放在原来location前面，即放在location位置，原来location位置以后的东西顺序后移
//notes.size();
//notes.remove(index);
//notes.toArray(a);//把这个ArrayList里的元素都复制到a数组中，然后进行输出,如下图所示，可以省略一个循环
}
12、对象数组
当数组的元素的类型是类的时候，数组的每一个元素都只是对象的管理者而非对象本身，
仅仅创建数组并不意味着创建了其中的每一个对象,String[] a=new String[10]，此时对象还没有创建出来,如果是int，则会产生a[0]=0;
for-each循环
for(int k:ia){ k++; }//没有任何用，因为这里的k只是原数组的复制品
对于对象数组却有所不同
因为 数组管理的那块东西 和 for-each循环里那个东西管理的 是同一个东西，会实现修改
13、集合容器
HashSet<String> s=new HashSet<String>();//集合不保存重复键值
System.out.println(s);//可以直接输出 [second,first] ArrayList也可以
//因为他们都实现了toString
public String toString(){
return ""+s[i];
}class Value{
private int i;
}
main(){
Value v=new Value();
v.set(10);
System.out.println(v);//输出的是奇怪的东西，继续在Value类里实现toString才能够输出
//return ""+i;
}注意：
集合容器中的元素不是在一块连续的存储空间内的，各个元素的位置是不连续且无序的，所以无法用index去索引任何一个元素的地址**（集合是无序的）** 因此，也不能用get()来获取某个位置的元素14、散列表
HashMap<Integer,String> m=new HashMap<Integer,String>();//注意不能是int,因为在容器中所有元素都必须是对象
m.put(key,value);
m.get(key);//可以获取到对应的value
m.keySet();//获取Set中不重复的键值个数
//同样也可以直接用println输出m15、继承与多态
子类可以继承得到父类的所有东西（构造方法除外，它是每个类所独有的），但并不代表全部可以使用。
每个成员有不同的访问属性
父类成员访问属性 在父类中的含义 在子类中的含义
public 对所有人开放 对所有人开放
protected 只有包内其他类、自己和子类可以访问 只有包内其他类、自己和子类可以访问
private 只有自己可以访问 不能访问
缺省 只有包内其他类可以访问 如果子类和父类在同一个包内：只有包内其他类可以访问 否则，相当于private，不能访问
protected:包内和子类可访问
缺省：在父类所在的包内可见，如果子类和父类不在一个包中，则也不能访问
private型变量在子类中也是存在的，只是不能直接访问，在子类中也不能更改他们的属性，如果定义了一个同名变量，则是与父类里面那个无关的独立的一个变量
构造一个子类对象时，先回调用父类的构造函数，再调用自己的，父类空间先被初始化，然后子类空间才会被初始化。 这样就有 可能会出现问题。
如果父类的构造函数是有参构造函数，那么子类如何给他传参呢？？
这里用到的是super(title); 父类构造函数会根据super中的参数去寻找它里面合适的构造函数
关于super:
//super是用来给父类传递参数的
super();//一个构造函数中只能使用一次super**（因为只有一个父类呀）**，并且super要放第一行子类和父类中都有print();时 用super.print();调用父类的
多态变量
对象变量可以保存其声明的类型的对象，或者该类型的**任何子类型的对象**
保存**对象类型**的变量是**多态变量**（是指一个变量可以保存不同类型的对象）
子类的对象可以被当作父类的对象来使用：
- 赋值给父类的变量
- 传递给需要父类对象的函数
- 放进存放父类对象的容器里
Java中所有对象变量都是多态的，他们能保存不止一种类型的对象
- 他们可以保存声明类型的对象，或声明类型的子类的对象
-
当把子类的对象赋值给父类的变量（不是对象对对象的赋值，而是让这两个东西管理同一个东西）的时候——发生了向上造型
*C++里面可以做对象对对象的赋值，但Java不能*
Vechicle v;
Car c=new car();
v=c;
c=v;//编译错误，父类的对象不能赋值给子类的变量
c=(Car)v;//v实际管理的是Car类型才行 （造型：声明类型和动态类型（实际传递进去的）不符）
//这样可能有风险 取决于v当时管理的对象是什么 只有它管理Car类型时才能被成功造型
//造型（括号围起来）：对象本身并没有发生任何变化，当做另一个类型来看待，不是“类型转换”
//运行时有几只来检查这样的转化是否合理 eg. ClassCastException多态
- 子类方法覆盖了父类方法，但具有相同的方法名称和参数表，仍然是父类中定义的那个方法，不过是新版本，子类对象调用执行子类自己的这个方法，父类对象执行父类的
- 注意是对象而非变量，因为一个类型为父类的变量有可能指向的是一个子类的对象
函数调用的绑定：通过对象变量调用函数时，调用哪个函数
静态绑定：根据变量的声明类型决定
动态绑定：根据变量的动态类型决定（默认）//运行的时候才知道是什么类型
- 在成员函数中调用其他成员函数也是通过this这个对象变量来调用的
- 所以所有成员函数的调用都应该看做是动态调用
覆盖(override)
子类方法和父类方法具有相同的方法名称和参数表的一对函数构成覆盖关系
通过父类变量调用存在覆盖关系导函数时，取决于**当时所管理的对象的类**的函数Object类
- 所有的类都是继承自Object的
-
成员函数：
toString(); equals();
向下造型:
public boolean equals(Object obj){//之前穿传去的是CD类型，所以下面要做一个向下造型
CD cc=(CD)obj;
return artist.equals(cc.artist));
}@Override
告诉编译器覆盖了父类的函数，注意**括号参数类型也会不能改的哦，public也不能去掉** 会产生编译错误，加了@的话16、抽象
抽象类（abstract)不能创建任何对象，仅仅表达接口，而不具体实现细节。但是**可以定义变量**，要**继承了这个抽象类的对象**才可以赋给这个变量。eg:
class Circle{...}
Shape c;
c=new Circle();//c实际是管理了子类的对象抽象类中可以实现抽象方法，也用abstract修饰，抽象方法是不完全的，它只是一个方法签名而完全没有方法体。
如果一个类有了抽象方法，这个类就**必须声明为抽象类**。
如果父类是抽象类，子类就必须**覆盖(即实现）所有**在父类中的抽象方法，否则子类也成为一个抽象类public abstract class Shape{
public abstract void draw(Graphics g);//注意不能有{}，不然就会报错
}17、接口：规定长啥样
接口（interface)是纯抽象类
所有的成员函数都是抽象函数
所有的成员变量都是public static final
Cell是一个接口类型，Field如果想要一个Cell,此时Fox和Rabbit都实现了这个接口，从而他们可以作为Cell给Field使用。
public interface Cell{//interface和class是同一级别，可以说是一种特殊的类
void draw(Grphics g,int x,int y,ints size);
}- 类用extends,接口用implements
- 类可以实现很多接口
- 接口可以继承接口，但是不能继承类
- 接口不能实现接口
- 设计程序时，要先定义接口，再实现类
- 任何需要在函数间传入传出的一定是接口而不是具体的类 ？？？留坑 不是很懂
18、instanceof
if(an instanceof Rabbit)//用于判断an是不是Rabbit类型的变量20、 内嵌类型：在类或接口内部定义的自定义类型
class A{//包围类
static class B{ static int x;}//内部类 可添加雨多成员函数才能具备的东西，eg. static,private
interface C{int y=0;}//内部接口
}//编译后将产生三个文件：A.class A$B.class A$C.class- 内部类可以访问囿类所有成员，包括私有
- 要访问内部类，需要通过囿类或囿类对象来访问
- 如果要将囿类对象自身传给内部类对象： 囿类对象名.this
- 外部类和内部类可以任意互访，但是外部类要通过创建内部类的对象来访问内部类
- 若 内部类 中有静态成员，则这个内部类必须是静态内部类 才能够通过A.B.x直接调用起哄的静态成员
21、GUI图形界面
- JButton类：可以实现一个按钮
JButton bt=new JButton("单步"); - JFrame类：实现一个框架
Swing：
- 所有东西都是部件,放在容器中,容器管理部件的时候会使用布局管理器(五个方位参数）,默认是BorderLayout;
- 采用事件监听器的事件处理模型，某个对象实现相关接口就可以成为相关事件的监听器，就可以注册到它想监听的组件上。
frame.add(bt,BorderLayout.NORTH);//一定要注意指定位置，否则会覆盖掉之前的东西
//因为参数缺省的时候默认是center,会覆盖掉前面的//匿名类
bt.addActionListener`(` new ActionListener(){
public void actionPerformed(ActionEvent e){
...
}
} `)` //ActionListener里面只有actionPerformed()函数- 在new对象的时候给出类的定义 形成匿名类
- 匿名类可以继承某类，也可以实现某接口
- Swing的消息机制广泛使用匿名类
//内部类
class StepListener implements ActionListener{
public void actionPerformed(ActionEvent e){
...
}
}
bt.addActionListener(new StepListener());//注意传进去要是实现了ActionListener的对象- 定义在别的类、函数内部
- 能直接访问外部类的资源，包括私有
- 外部是函数时，只能访问那个函数里final的变量
反转控制
把一个实现了ActionListener接口的对象交给JButton（注册），JButton就能反过来去调用里面的actionPerformed()函数，实现相关操作。（也叫Swing的消息机制）
MVC模式
22、异常处理
import java.util.Scanner;
class test
{
public static void main(String[] args) {
int []a=new int[10];
int idx;
java.util.Scanner in=new Scanner(System.in);
idx=in.nextInt();
try{
a[idx]=10;
System.out.println("hi");
}catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("caught");
}
catch(Typel e){
...
}
...
}
}//try-catch语句捕获异常,后面可以跟着很多catch拿到异常对象之后：
String getMessage();
String toString();
void printStackTrace();
如果没办法处理，可以再度抛出
catch(Exception e){
System.err.println("An exception was thrown");
throw e;
}//(如果在这个层面上需要处理，但是不能做最终的决定，就继续抛出，给下一个catch处理）
什么能扔？
- 任何继承了Throwable类的对象//throws XX
- Exception类继承了Throwable
- throw new Exception()
- throw new Exception("HELP");//两种形式
catch怎么匹配？
Is-A关系
抛出自诶异常会被捕捉父类异常的catch捉到
能捕捉到任何异常：
catch(Exception e){
System.err.println("Caught an exception");
}如果你的函数可能会抛出异常，就必须在函数头部加以声明
void f() throws TooBig,TooSmall{
...
}23、I/O流
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。