Java中，二维数组的定义和一维数组是一样的。
public class Welcome {
public static void main(String[] args) {
int [][] num;
num=new int[3][4];
num[0][1]=1;
num[1][3]=12;
num[2][2]=21;
}
}
Java中二维数组的列数可以不同，比如第一行是2列，第二行是4列，等等。
有些类似与c语言中的指针数组。
public class Welcome {
public static void main(String[] args) {
int [][] num;
num=new int[3][];
num[0]=new int[2];
num[1]=new int[4];
num[2]=new int[3];
num[0][1]=12;
num[1][3]=23;
num[2][2]=34;
System.out.println(num[0][1]);
System.out.println(num[1][3]);
System.out.println(num[2][2]);
}
}
在java中没有定义的自动赋值为0.
在定义时可以为二维数组来定义，但是在赋初值时 ，不要在定义大小了
int [][] num=new int[3][]{1,2,3,4,5,2,3,4,5,6} //error
public class Welcome {
public static void main(String[] args) {
int [][] num=new int[][]{1,2,3,4,5,2,3,4,5,6}; //error
int [][] num=new int[][]{{1,2,3,4,5},{2,3,4,5,6}}; //ok
}
}
定义二维数组还有一种方式
public class Welcome {
public static void main(String[] args) {
int [][] num={1,2,3,4,5,2,3,4,5,6}; //error
}
}
也可以定义不规则的二维数组
public class Welcome {
public static void main(String[] args) {
int [][] num={{1,2,3},{4,5},{2}};
System.out.println(num[0][2]);
System.out.println(num[1][1]);
System.out.println(num[2][0]);
}
}
在java中，不能使用像int num[3];这样的定义数组，在定义数组时不能分配空间的大小，只能通过为数组添加对象来分配空间。
public class Welcome {
public static void main(String[] args) {
int num[];
num=new int[3];
}
}
或者在定义时直接定义大小。
public class Welcome {
public static void main(String[] args) {
int num[]=new int[3];
}
}
Java中建议使用int[] num 这种方式这种方式定义了一个int类型的数组[],数组名称为num。
在定义时还可以直接初始化
public class Welcome {
public static void main(String[] args) {
int[] num={1,2,3};
}
}
但是这种方法只能在定义时进行。
public class Welcome {
public static void main(String[] args) {
int[] num=new int[]{1,2,3};
}
}
还可以使用new int方法来定义，如上
int[] num =new int[3]{1,2,3};这样的写法也是不允许的。不能分配空间大小。
最简单的方法是
public class Welcome {
public static void main(String[] args) {
int [] num;
num=new int[3];
num[0]=1;
num[1]=12;
num[2]=21;
System.out.println(num[0]);
System.out.println(num[1]);
System.out.println(num[2]);
}
}
对字符类型赋值使用单引号' ',
public class Welcome {
public static void main(String[] args) {
char ch;
ch='a';
System.out.println(ch);
}
}
输出为a
字符类型还可以直接使用整数来赋值，因为java中对字符类型使用的是uncode字符。
public class Welcome {
public static void main(String[] args) {
char ch;
ch=98;
System.out.println(ch);
}
}
输出为b
在java中小数常量被默认为double类型，如1.3默认为double类型。如果要声明为float类型，需要在之后加f，如1.3f
public class Welcome {
public static void main(String[] args) {
float f;
f=1.3f;
System.out.println(f);
}
}
输出为1.3
在java中boolean 布尔类型只有2个取值是true和false，不能赋值为1之类的整数。
public class Welcome {
public static void main(String[] args) {
boolean bool;
bool=true;
System.out.println(bool);
}
}
输出为true
在做条件判断的时候，不能再像c语言那样使用if（1）或where（1）这样的语句。
只能写为if（true）或where（true）这样。
Byte b；
b=3；
b=b*3;
System.out.pringln(b);
编译时会提示发现int类型，需要byte类型，这是因为b=b*3java会自动将参与运算的数据自动转换为int类型。如果要输出正确的数据则要进行强制类型转换。
b=(byte)(b*3);
这样才会对
public class Welcome
//声明public的类，应该作为文件名，一个源文件只能有1个或没有public的类
{
public static void main(String[] args)
{
System.out.print("你好\n");
//不加ln，不加换行。或者在之后加\n也是换行
System.out.println("欢迎使用java开发");
//输出命令，牢记！
}
}
对象的特征：状态（state）和行为（behabior）
人 身高，体重 吃饭，睡觉
现实世界对象的状态保存在软件对象的变量中，先是世界对象的行为通过软件对象的方法（函数）来实现、。
类和对象
把相似的对象归成一个类。
类就是模版定义了通用与一个特定种类的所有对象的状态（变量）和行为（方法）
类是创建对象的模版，对象是类的实例。
掌握面向对象的难点在于思路的转换，我们通常考虑解决问题的方法。而不是考虑将问题抽象成对象再去解决它。
编写一个驾驶汽车的方法
面向过程的程序设计： 编写一个方法，void drivercar();
面向对象的程序设计： 将一辆汽车看成一个对象，将所有汽车对象的共性抽取出来，设计一个类Car,
类中有一个方法void drive(),用Car这个类实例化一个具体的对象car，调用：car.drive().
new关键字的作用。
为对象分配内存空间，引起对象构造方法的调用。为对象返回一个引用。
构造方法的名字和类名相同，并且没有返回值。
构造方法主要用于为类的对象定义初始化状态。
我们不能直接调用构造方法，必须通过new关键字来自动调用，从而创建类的实例。
java的类都要求有构造方法，如果没有定义构造方法，java编译器会为我们提供一个缺省的构造方法，也就是不带参数的构造方法。
缺省构造方法默认值：数值 0
booeean false
char ”\0"
对象 null
方法的重载：重载构成的条件：方法的名称相同，但是参数类型或参数个数不同，才能构成方法的重载。
特殊变量this
this变量代表对象本身。
当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法的局部变量），
使用this区分成员变量和局部变量
使用this简化构造函数的调用。可以通过不带参数的构造方法调用带参数的构造方法。
Point(int a,int b)
{
x=a;
y=b;
}
Point()
{
this(1,2);
}
一个类所有的实力（对象）调用的成员方法在内存中只有一份拷贝，尽管在内存中可能有多个对象，
而数据成员在类的每个对象所在内存中都存在这一份拷贝。this变量允许相同的实例方法为不同的对象工作。
每当调用一个实例方法时，this变量将被设置成引用改实例方法的特定的类对象。方法的代码接着会与this所代表的特定数据建立关联。
内存模型 的概念
静态方法和静态变量时属于某一个类，而不属于类的对象。
静态方法和静态变量的引用直接通过类名引用。
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之，则可以。
可以用类的对象obj去调用静态的方法method（），如 obj。method（）。
final定义的变量要在定义时初始化也可以放在构造函数中实现
常量通常定义为静态的，是为了节省内存。这时就要在定义时初始化。
final定义的常量一般默认用大写。
继承
继承是面向对象的关键
在java中，通过关键字extends继承一个已有的类，被继承的称为父类（超类，基类），新的类称为子类（派生类）。
在java中，不允许多继承。
方法的覆盖
在子类中定义一个与父类同名、返回类型、参数类型均相同的一个方法，称为方法的覆盖。覆盖发生在子类与父类之间。
class Animal
{
int height,weight;
void eat()
{
System.out.println("animal eat");
}
void breathe()
{
System.out.println("animal breathe");
}
void sleep()
{
System.out.println("animal sleep");
}
}
class Fish extends Animal
{
void breathe()
{
System.out.println("fish bubble");
}
}
class Integration
{
public static void main(String[] args)
{
Animal an=new Animal();
Fish fh= new Fish();
an.breathe();
fh.height=30;
fh.breathe();
}
}
特殊变量super，提供了对父类的访问。
可以使用super访问父类被子类隐藏的变量或覆盖的方法。
每个子类构造方法的第一条语句，都是隐含的调用super(),如果父类没有这种形势的构造函数，那么在编译的时候就会报错。
class Animal
{
int height,weight;
void eat()
{
System.out.println("animal eat");
}
void breathe()
{
System.out.println("animal breathe");
}
void sleep()
{
System.out.println("animal sleep");
}
}
class Fish extends Animal
{
void breathe()
{
super.breathe();
super.height=40;
System.out.println("fish bubble");
}
}
class Integration
{
public static void main(String[] args)
{
//Animal an=new Animal();
Fish fh= new Fish();
//an.breathe();
fh.height=30;
fh.breathe();
}
}
多态性，子类有就调用子类的。没有就调用父类的
instanceof
比较一个实例是否是一个类的实例
按位与
同时开才亮
关 关 暗
开 关 暗
关 开 暗
开 开 亮
01101101 与
00110111
00100101
只有11为1
按位或
任何一个开都亮。同时关才暗
01101101 或
00110111
01111111
只有00为0
按位异或
处于不同的状态就亮
01101101 异或
00110111
01011010
只有01或10为1
按位取反
0变1，1变0
java中的3个移位预算符
左移：<<
带符号右移：>>
无符号右移：>>>
数 x x<<2 x>>2 x>>>2
17 00010001 00`01000100 00000100`01 00000100`01
-17 11101111 11`10111100 11111011`11 00111011`11
把数向左移动一位。相当与乘以2，向右移动一位，相当与除2。
源码
将最高位表示符号位0正1负其余代表数值本身的绝对值
＋7 源码00000111
－7 源码10000111
问题
＋0源码 00000000
——0源码 10000000
表示方式不唯一，所以计算机中不采用这种方式
反码
一个数为正。则它的反码与源码相同；一个数为负。则符号位为1。其余都是对源码取反
＋7 反码 00000111
——7 反码 11111000
问题
＋0 反码 00000000
——0 反码 11111111
计算机中也不采用这种方式
补码
利用溢出，我门可以将减法变成加法。
对于10进制 9－4＝5
因为4＋6＝10
我们将6作为4的补数。将上面的减法变成加法
9+6=15
去掉高位1 得到5
一个字节表示一个数1个字节有8位超过就进1
一个数为正源码。反码。补码相同。一个数为负。则符号位为1。其余各位对源码取反。然后整个数加1。
＋7 00000111
——7 11111000
11111001
+0 00000000
_0 11111111 加1
100000000 丢弃最高位
00000000