变量，数据类型和类

变量和数据类型

类型	关键字
包引入和包声明	import package
用于类的接口声明	class extends implements interface
修饰符	abstract final native private protected public static synchronized transient volatile
流程控制	break case continue default for do while if else return switch
创建对象	new
引用	this super
方法返回类型	void
异常处理	catch finally throw throws try
某些数据类型	false true null

保留字

byValue cast false future generic inner operator outer rest true var goto const null

java标识符命名规范

元素	规范	示例
类名	Pascal	Person,StudentDemo
变量名	Camel	age,height,avgValue
方法名	Camel	getAge,setUserName
包名	全小写	com.java,edu.zsc
常量名	全大写	PI,MAX_VALUE

java基本数据类型

类型	关键字	bit	取值范围	默认
字节	byte	1	-128~127	0
短整型	short	2	-2¹⁵~2¹⁵-1	0
整型	int	4	-2³¹~2³¹-1	0
长整型	long	8	-2⁶³~2⁶³-1	0
单精度浮点数	float	4	1.4E-45~3.4E+38	0.0
双精度浮点数	double	8	4.9E-324~1.8E+308	0.0
字符型	char	2	Unicode	‘\u0000’
布尔型	boolean	1	true/false	false

类型间的转换是否丢失精度与bit有关。
所有的非基本数据类型都是引用数据类型。
类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型。

类和对象

类class是某类事物的共性描述，对象object是某类事物的个体存在。

类的定义

class 类名 extends Object{
成员变量
成员方法
构造方法
toString()
equals(Object obj){//
	if(!(obj instanceof 类名)){
		return false;
	}else{
		类名 p=(类名) obj;
		//TUDO再进行成员变量的判断
	}
}
hashCode()//将改对象在JVM的内部地址转换成一个整数
}

类的分类

外部类

被public修饰的类是外部类，一个包中只能有一个外部类。

内部类

一.普通内部类
1.适用于外部类当中，但依赖外在的类，可以自由的使用外部类的变量和方法。
2.变量和方法不能声明为静态的。(类的编译顺序：外部类–静态方法或属性–内部类)
3.普通内部类能引用外部类的所有属性或者方法。
4."外部类类名.普通内部类名 对象名 =外部类对象名.new 普通内部类名();"来实例化。
5.可以实现多重继承(多个内部类继承不同的其他类，相当于外部类继承了多个类)(若使用接口实现，这个需要重写方法，而使用内部类的方式不需要)
6.避免修改接口而实现同一个类中两种同名方法的调用。(原理同上)。
7.实现隐藏，使用private修饰内部类。(外部类当作控制器，根据权限分配内部类)
二.静态内部类
1.静态内部类适用于外部类当中，但又不依赖外在的类，使用它可以提高程序的运行效果。
2.属性和方法可以声明为静态的或者非静态的。
3.静态内部类只能引用外部类的静态的属性或者方法。
4.可以使用"外部类类名.静态内部类名 对象名 = new 外部类类名.静态内部类名();"来实例化。也可以”外部类类名.静态内部类名.方法名()"来调用方法或成员。
三.区别
静态内部类是指被声明为static的内部类，可不依赖外部类实例化；而非静态内部类需要通过生成外部类来间接生成。
静态内部类只能访问外部类的静态成员变量和静态方法，而非静态内部类由于持有对外部类的引用，可以访问外部类的所有成员
静态内部类唯一的作用就是随着类的加载（而不是随着对象的产生）而产生，以致可以用类名+静态成员名直接获得。这个类没有必要单独存放一个文件，它一般来说只被所在外部类使用。
区别
TODU普通内部类不能使用static

package lei.demo1;
public class Test1 {

    private final String name1="外部类test1";
    private static String name2="外部类test1";
    public void a(){
        System.out.println("我是"+name1);
    }

    class Test2{//内部类课调用外部类的一切，和外部类的方法同等权力
        //private static int age=1;//普通内部类不能有静态成员和方法
        class Test4{
            private String name1="内部类test4";
            public void a(){
                System.out.println("我是"+ Test1.this.name2+"的"+Test2.this.name1+"的"+name1);
            }
        }
        private String name1="内部类test2";
        public void a(){
            System.out.println("我是"+ Test1.this.name1+"的"+this.name1);
        }
    }
    static class Test3{//静态内部类,只能调用静态成员和方法
        private String name1="静态内部类test3";


        public void a(){
            System.out.println("我是"+ Test1.name2+"的"+this.name1);
        }

    }

    public static void main(String[] args) {
        Test1 test1=new Test1();//外部类
        Test1.Test2 test2=test1.new Test2();//普通内部类
        Test1.Test3 test3=new Test3();//静态内部类
        Test1.Test2.Test4 test4=test2.new Test4();//普通内部类的普普通内部类
        //Test1.Test3 test5=test1.new Test3();
        test1.a();
        test2.a();
        test3.a();
        test4.a();
        test4.name1="修改";
        test4.a();
    }
}

局部类

静态方法中的局部类仅能够访问静态成员变量。局部内部类不能在方法以外的地方使用,也不能使用访问控制符和static修饰符即不能定义或者声明任何的静态成员，但是可以有构造函数。

public class test1 {
    private int a;

    public void test() {
        System.out.println("外部类...");
    }
    //局部内部类是嵌套在方法里面的
    public void testB() {
        class ClassB {
            private int b;

            public void testB() {
                System.out.println("局部类...");
            }
        }
        ClassB b = new ClassB();   //局部类创建实例
        b.testB();					//实例调用testB()方法
    }
}

匿名内部类

这里要和匿名对象区分开，匿名对象是创建对象直接使用而没有对象名。使用完后匿名对象会被销毁无法找回。

new Person().eat()  //eat方法被一个没有名字的Person对象调用了。

使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
不能存在任何的静态成员变量和静态方法。匿名内部类属于局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。但不能定义构造函数。
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

abstract class Person {
        public abstract void like();
}

public class Test1 {
    public static void main(String[] args) {
        Person p = new Person() {
            public void like() {
                System.out.println("like money");
            }
        };
        p.like();
    }
}

匿名内部类和匿名对象经常用在线程的创建