JAVA笔记(2)变量初始化，数组，包，继承，修饰符

变量初始化

未初始化的变量不能被使用。声明一个对象时要为他分配内存

Object obj=new Object();

int对象初始化时要为他指定内存。

int   i = 10;
int[] a = new int [10];

对象组：

Object[] obj=Object[10];//创建对象指针组。指向地址
for(int i=0;i<10;i++)
    obj[i]=new Object   //为对象指针组分配内存。

对象组内的变量在内存中不是连续的。
任何数组对象都有一个成员变量都有.length成员，存有数组的长度。

obj[i].length;

二位数组的声明和初始化

int[][] a=new int[2][3];//创建二维矩阵数组
for(int i=0;i<a.length;i++){
    for(int j=0;j<a[i].length;j++)
        a[i][j]=9;
}

int[][] a = new int a[2][];//1、可以是不同长度 2、数组生成时必须指定长度。
a[0]=new int [5];
a[1]=new int [6];

运算符

运算符：一元二元三元。算数关系逻辑。

a+b;
a-b;
a*b;
a/b;
a%b//和被除数符号位一致，和被除数符号位无关。
a++;
a--;//自增自减

算术运算的结果的类型不能低于int类型。低于Int类型的数据自动提升为int。

byte b=0;
byte b1=6;
byte b2=6;
b=b1+b2;//错误
int i=0;
i=b1+b2;//正确
b=(byte)(b1+b2);//正确

强制转化运算：砍掉多余的字节。

int i=1000;
byte b=(byte) i ;//i=-24

浮点数转化为整数：砍掉小数

x = x op y;
x op = y;

byte x=0,y=1;
x=x+y;//编译错误提升类型为了int 
x+=y; //不会出错。会进行强制数据类型转化。

小类型可以赋值给大类型，但是大类型给小类型赋值就会报错。

大小关系从小到大：byte short int long float double 

byte[] i...;
int[] j...;
i=j;//报错
j=i;//报错

位移运算

>>//右移
<<//左移
>>>//无符号移位。符号位永远都补0

左移有可能改变符号位（溢出）。

int i=...;
i>>33;
i>>1;
结果相等。虚拟机会将33%32后对i进行移位

逻辑运算 优先级低于算术运算
与或非，位反运算。

i=~i;//每个比特位取反后加1

优先级

&>^>|
&& ,  || 只接受boolean类型的数据。

短路的运算符：

function_a() && function_b()
当function_a()为假，就不会解析function_b()可以理解为function_b()不会运行。

三元运算符

a?4:4.5
//整个表达式的类型由后面两个操作数最大的类型来确定。上面的表达式返回范围在{4.0,4.5}之中。

命名冲突

//可以定义包来解决命名冲突的问题。
package a;
a.Object;
//对类的名称进行了延长

包名冗余：多层包结构

import a,b,c.Student;
//在类声明之前在package之后

java,javax是java官方定义的包名前缀
声明包名时不能用java和javax开头

import java.util.*;
import java.io.*;
import java.net.*;
import java.sql.*;

class A{
    java.util.date;
}

在源文件时声明包：

package a;
public class Helloworld{
    public static void main(string arg[]){
        System.out.println("hello world ");
    }
}

公开类保存为文件时，文件名必须和类名一致。
以上文件编译时必须加上javac -d选项。不加这个会丢失包的信息。结果就是找不到这个包

>javac Helloworld -d+文件夹名，缺省则存在当前目录。
>java a.Helloworld

文件夹的好处：1、存放同名文件，2、名称分类管理。
包的作用与之类似。
编译时编译器会将包的信息将转化为文件夹的层次结构。

path 变量：可执行程序的搜索目录。
所有包名小写。

javac xxx.java -d -classpath (-c) 
//-classpath 用来导入类路径分隔符用分号（windows）,ubuntu 苹果用冒号。

java文件在发布时用的是.jar文件。
用jar命令打包

继承

java只有公有继承，子类继承父类的一切特征。并且是单一继承

    //默认java.lang.Object为所有类的基类。
    //java.lang为java的原包，自动导入。

访问权限

//访问权限 private public protect 
//没有对应的修饰符为同包权限。
package a;
class student{
    private int age;//只能在类体中访问
    char[] TeacherName;
}
class teacher{
    //可以访问TeacherName;
}

保护权限：

public class teacher{
    protected float money;
}
//同包可访问，派生类可访问。

派生用extends关键字。
protected 只能用子类名来访问父类中的某个成员。
不能直接用父类的名来访问。

public class boss extends teacher{
        public static main(string arg[]){
            teacher t=new teacher();
            t.money++;//报错
            boss b=new boss();
            b.money ++;//正确
        }
}

同包权限：

class A{
int i=new int;
}//只能在这个中访问

修饰符

final

final int i;
i=5;
//之后再不能对i赋值

final后跟初始值，可以用来修饰变量也可以用来修饰类，修饰符之间没有顺序要求

final class A{
    //A没有子类
    final void a(){
        //a不允许被覆盖
    }
}

static

class student{
    static int ClassNum;
    //与任何实例无关，有无对象存在ClassNum有一只存在。(类共享)
    //要通过类名来访问类的静态成员。相当于全局变量。
}

System.out=null;//错误
//System.out 是final不允许改值,可以通过类名访问，所以是static public