java学习笔记

class

• 一个java文件中只能有一个主类 public class demo //demo名字跟java文件名必须一样

局部变量：

• 在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：

• 成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：

• 类变量也声明在类中，方法体之外，但必须声明为static类型。

创建对象

• 每个类都有其构造方法 如果没有写 java编辑器会自动加上一个构造方法

常用快捷键

eclipse

• 生成类的主方法：main alt+/
• 控制台打印：syso alt+/
• 生成返回值对象： shift+alt+l

idea

• 生成类的主方法：psvm tab
• 控制台打印：sout tab
• 生成返回值对象： ctrl+alt+v
• 成员变量生成set get 方法 alt+insert

java 基本数据类型

• 变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。

java 的两大数据类型:

• 内置数据类型
• 引用数据类型

内置数据类型

• byte 8进制
• short 16进制
• int 32进制 java中的数值运算最低要求是int类型 如果参与运算的变量类型都没有超过int类型，则它们都会被自动升级为int类型再进行运算，所以它们运算后的结果类型也是int类型
• long 64进制
• float 32进制
• double 64进制 (双精度浮点型)它能表示比float更高精度的数值。double是java基本类型中能达到的最高精度，如果还不能满足要求，可以使用java中的bigdecimal类。默认值是0.0。
• boolean true or false default = false 例子：boolean one = true
• char 单一的 16 位 unicode 字符 char 数据类型可以储存任何字符 unicode将人类语言的所有已知字符映射成16位数字，所以java中的char是16位的。默认值是\u00000。

所有数字类型的包装类都是number的子类

包装类

• 默认值为null

七种数值类型 按大小排序

• byte <（short=char）< int < long < float < double

类型转换规则

• 类型转换的总则是：小可直接转大、大转小会失去精度

java 变量类型

• 类变量
• 实例变量
• 局部变量

修饰符

1 访问控制修饰符

• public 修饰类
• default
• private 只修饰成员 修饰的私有内容只在本类中有效
• protected

2 非访问修饰符

• static 用来声明独立于对象的静态变量 无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
• final 修饰类 被修饰的类不能被继承，没有类能够继承 final 类的任何特性。类中的 final 方法可以被子类继承，但是不能被子类修改。声明 final 方法的主要目的是防止该方法的内容被修改。
• abstract 抽象类 抽象方法
• synchronized
• volatile

方法重载

• 就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。
• java编译器根据方法签名判断哪个方法应该被调用。
• 方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
• 重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法

构造方法

• 当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
• 通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
• 不管你与否自定义构造方法，所有的类都有构造方法，因为java自动提供了一个默认构造方法，它把所有成员初始化为0。
• 一旦你定义了自己的构造方法，默认构造方法就会失效。

访问器方法

用于获取有关对象的信息的方法称为访问器方法

string a = "grhdsadsdas"; int wordl = a.length();

增强for循环

int [] a = {1,2,3}; for (int i : a) { //i代表遍历的每一项的值 相当于js里foreach的v system.out.println(i); }

java 数组

创建数组变量

• int [] arrs = {1,2,3,4};
• int [] arrs =new int[4];
• int [] arrs =new int{0,1,2,3,4,5,6,7,8,9};

面向对象

继承的特性

• 子类拥有父类非private的属性，方法。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如a类继承b类，b类继承c类，所以按照关系就是c类是b类的父类，b类是a类的父类，这是java继承区别于c++继承的一个特性。

• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

构造函数

• 成员变量-属性

• 类里面定义的成员变量一般都是私有的 对应set 和 get 方法

• 成员方法-行为
• new一个对象时会调用改构造函数 对对象进行初始化
• 创建对象必须要通过构造函数初始化 用于对象初始化
• 一个类中可以有多个构造函数 传不同的参数
• 如果一个类中有了有参构造，那么必须写写一个无参构造，否则会报错

构造函数和一般函数的区别

• 构造函数 对象创建时。就会调用对应的构造函数 且只调用一次
• 一般函数 对象创建后。需要使用该方法时再去手动调用 可多次调用
• 构造函数首字母大写 一般函数首字母小写

构造函数中的this 成员变量和局部变量重名时 用this区分

• this指向当前构造函数所属的对象,简单说哪个对象调用了所在函数，this就代表哪个对象
• 代表本类对象

匿名对象 没有名字的对象 当对象只对方法调用一次时可使用匿名对象

car a = new car(); a.run(); a.run(); new car().run();//一次调用 new car().run();//两次调用 此时是两个不同的对象分别调用了一次run方法

static的特点

• static是一个修饰符
• static修饰的成员被所有对象所共享
• static优先于对象存在，因为staticd的成员随着类的加载就已经存在了
• static修饰的成员多了一种调用方法，就可以直接被类名所调用，类名.静态成员 person.name
• static修饰的数据是共享数据，对象的存储是特有数据

成员变量（实例变量） 静态变量 （类变量）

public class person { string country = "cn"; //成员变量 实例变量 static string name; //静态变量 类变量 static int age = 0; public void show() { age++; system.out.println(name+":"+country+":"+age); } public static void main(string[] args) { person person = new person();//类类型变量 person.name = "grh"; person.show(); } }

成员变量和类变量的区别

• 静态前面省略的类名 非静态省略的是this

public class person {
    static string country = "cn";
    int num = 0;
    public void show(){
        system.out.println(person.country+":"+this.num);
    }
    public static void main(string[] args){

    }
}

 

主函数

public static void main(string[] args){ //new string[0]
        system.out.println(args);//[ljava.lang.string;@1540e19d
        system.out.println(args.length);//0
    }

 

什么是包

• 用来对类进行一个分类
• 通过import引入包中的类 deafault 修饰的 变量或者方法只能通过包的引用使用、

继承

• java只支持单继承，不支持多继承 一个类只能有一个父类
• 因为多继承会存在安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类不确定运行哪一个
• 父类也叫超类（super）

子父类中变量的特点

• 如果子类和父类中有相同的变量 以子类的为准 如果想要在子类中访问父类的变量 需用到super.num

class father {
    int num = 1;
}
class son extends father{
    int num = 2;
    void show(){
        system.out.println(super.num);
    }
}
class extendsdemo {
    public static void main(string[] args){
        son son = new son();
    }
}

 

重写 （覆盖）方法重载

• 当子类继承父类，沿袭了父类的功能，到子类中，子类中需要该功能，但是功能的内容不同，此时就需要覆盖
• 子类覆盖父类，子类权限必须大于父类权限，才可以覆盖，否则编译失败
• 重载：只看同名函数的参数列表
• 重写：子夫雷方法要一模一样
• 子类必须要访问父类的构造函数

final修饰符的特点

• 被final修饰的类无法被继承
• 被final修饰的方法无法被重写
• 被final修饰的变量只能被赋值一次，既可以修饰成员变量，也可以修饰局部变量，在描述事物时，一些数据的出现值是固定，那么此时为了增强阅读性，就可以给这个值给一个固定值。且这个值不需要改变，所以加上final修饰。
• 被final修饰的变量又叫做常量，书写规范：全部大写字母，如果有多个单词，用下划线隔开

抽象（abstract）

• 抽象方法必须存在于抽象类中
• 抽象类不可以用new创建对象。因为调用抽象方法没有意义
• 抽象类和抽象方法必须被abstract修饰
• 抽象类中的抽象方法如果要被调用，必须由子类复写所有的抽象方法后，建立子类对象调用,如果父类有两个抽象方法，子类只复写其中一个，则该父类依然是一个抽象类无法使用其中的抽象方法 （达到强制复写方法的效果）

接口

• 接口存在多继承，因为接口中没有方法体，可以随便继承
• 接口可以用来多实现
• 类与接口之前是实现关系，类可以在继承一个类的同时实现多个接口

多态 （对象上的体现，函数的重载）

可以理解为事物存在的多种体现形态

• 例子：人：男人，女人 动物：猫，狗
• 函数重载体现

1 多态的体现

• 父类的引用指向了自己的子类对象 animal a = new cat();

2 多态的前提

• 类与类之前存在继承，或者实现关系
• 存在覆盖

3 多态的好处

• 增加代码的扩展性

4 多态的应用

• 建立一个工具类 用来调用其他类的方法

多态中成员函数的特点（非静态）

• 在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有。编译通过,如果没有失败。
• 在运行时期：参阅对象所属的类中是否有调用的方法。
• 简单的总结

多态中成员变量的特点

• 无论编译和运行，都参考左边（引用型变量所属的类）

object类

• 所有类的爸爸

内部类

内部类的访问规则

• 1 内部类可以直接访问外部类中的成员变量，包括私有 原因：因为内部类中持有了一个外部类的引用，格式，外部类名.this outer.this.num
• 2 外部类要访问内部类的成员变量，必须要建立内部类对象
• 3 内部类可以被私有private修饰
• 4 直接访问内部类： outer.inner in = new outer().new inner();
• 5 当内部类中定义了静态成员 该内部类必须是静态的

异常

异常就是程序在运行时出现不正常情况

• 1 对于严重的，通过error类进行描述 一般不写针对性的代码进行处理
• 2 对于非严重的，通过expection类进行描述 可以使用针对性的代码进行处理

泛型

• 避免向下转型带来的安全隐患。

• 泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
• 为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

泛型的特殊之处:

• 静态方法不可以访问类上定义的泛型
• 泛型定义在方法上，放在 void的前面

集合 collection

list 元素是有序的，元素可以重复，因为该集合体系有索引

• arraylist 是不同步的 底层的数据结构使用的是数据结构。特点：查询速度快。但增删稍慢
• linkedlist 底层的数据结构使用的是链表结构。特点：增删速度快，查询稍慢
• vector 是同步的，其他的同arraylist 已被取代

集合 map<k,v> k:此映射键的类型 v:映射值得类型

• 1 添加 put(k key v value)
• 2 删除 clear()
• 3 判断 containskey() containsvalue()
• 4 获取 get(object key) 返回value entryset()

map常见子类

• hashtable:底层是哈希表数据结构 不能存入null键null值 同步
• hashmap:底层是哈希表数据结构 能存入null键null值 不同步
• treemap:

数组转集合

• aslist 数组转换成集合后不能使用集合的增删方法 例如add，因为数组的长度是固定的，如果增删会报错不支持操作异常
• 为什么要把数组转换为集合，因为集合的方法比较多。可以使用集合的思想和方法

装箱和拆箱

jdk1.5之前的方法

public class testdemo {
    public static void main(string args[]) {
        integer x = 1;
        int temp = x;
    }
}

 

现在的方法

public class testdemo {
    public static void main(string args[]) {
        integer x = 1;
        int temp = x;
    }
}

 

为什么要有自动装箱的机制，为了使用object接收基本数据类型

public class testdemo {
    public static void main(string args[]) {
        object x = 10;//自动装箱成integer integer向上转型成object
        int a = x;//这么写不能编译通过
        int a = (integer) x;//object先向下转型成integer 在拆箱成int
        system.out.printin(x);//可以编译通过
    }
}