首页 > > 程序设计 > Java技术 >

java学习笔记

2018-09-01 05:39:38来源：博客园阅读 ()

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);//可以编译通过
    }
}