Java基础

一.java基础部分（基本语法，java特性）

1.标识符

1)、只能由字母（a-z，A-Z），数字（0-9），下划线（_）和美元符号（$）组成

2)、不能以数字开头

3)、不能与关键字重名

4)、严格区分大小写

2.常量与变量

1)、变量的三个元素：变量类型，变量名，和变量值

驼峰命名法：

1.小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog；

2.大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName；

3.不过在程序员中还有一种命名法比较流行，就是用下划线“_”来连接所有的单词，比如send_buf

2）常量：常量代表程序执行过程中不能改变的数据。

                我们可以把它理解成一种特殊的变量，只不过它的值被设定后，在程序运行过程中不允许被改变。

3.数据类型

byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。

short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。

int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。

double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

boolean：只有true和false两个取值。

char：16位，存储Unicode码，用单引号赋值。

简单类型	boolean	byte	char	short	Int	long	float	double
二进制位数	1	8	16	16	32	64	32	64
封装器类	Boolean	Byte	Character	Short	Integer	Long	Float	Double

Java引用类型

Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

引用类型：底层结构和基本类型差别较大

JVM的内存空间：

（1）. Heap 堆空间：分配对象 new Student（）

（2）. Stack 栈空间：临时变量 Student stu

（3）.Code 代码区 ：类的定义，静态资源 Student.class

eg：Student stu = new Student（）； //new 在内存的堆空间创建对象

       stu.study(); //把对象的地址赋给stu引用变量

上例实现步骤：

     a.JVM加载Student.class 到Code区

     b.new Student()在堆空间分配空间并创建一个Student实例；

     c.将此实例的地址赋值给引用stu， 栈空间；

4.运算符

5.流程控制语句

选择结构:

　　也叫分支结构 根据条件的不同,有选择的执行某一片代码 ,Java提供了两种  if结构    switch结构 

if的第一种格式

　　if(条件){
　　　　语句块
　　}

if的第二种格式:

if(条件){

　　语句块 1

}else{

　　语句块2

}

if语句的第三种格式:

if(条件1){

　　语句块1
}else if(条件2){

　　语句块2
}else if(条件3){
　　语句块3
}
...
else if(条件n){

　　语句块n
}else{

　　语句块n+1
}

选择结构switch

语法结构

switch(表达式){
case 目标值1:
　　　　语句块1
　　　　break;
case 目标值2:
　　　　语句块2
　　　　break;
case 目标值3:
　　　　语句块3
　　　　break;
...
case 目标值n:
　　　　语句块n+1
　　　　break;
default:
　　　　语句块n+1
　　　　break;

}

for循环:
for(初始化语句;条件;步进表达式){
　　循环体
}

while 循环:
初始化语句
while(条件){
　　循环体
　　步进语句
}

do ... while循环
初始化语句
do{
　　循环体
　　步进语句
}while(条件)

跳转语句可以控制循环的执行:
break : 在循环中使用的时候 表示结束当前循环
在switch语句中使用 表示跳出当前的switch结构

continue: 在循环中使用, 表示结束本次循环 进行下一次循环
跳转语句 脱离循环没有意义

6.方法

7.数组

声明数组变量：dataType[] arrayRefVar; // 首选的方法

                         dataType arrayRefVar[]; // 效果相同，但不是首选方法

eg: // 定义数组 double[] myList = new double[2];

                         myList[0] = 5.6;   myList[1] = 4.5;

或者：              double[] myList = {1.9, 2.9, 3.4, 3.5};

// 打印所有数组元素

for (double element: myList) {

      System.out.println(element);

}

8.注释

二.关键字

三.面向对象

1.面向对象思想

             Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。

　　　　这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。

　　　　面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

              面向对象的语言中，包含了三大基本特征，即 封装、继承 和 多态。 

2.类与对象

•     类：是一组相关 属性 和 行为 的集合。可以看成一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
•    属性：就是该事物的状态信息。
•    行为：就是该事物能够做什么。
•    对象：是一类事物的具体体现。 对象是类的一个 实例，必然具备该类事物的属性和行为。
•     3、类与对象的关系
• •      类 是对一类事物的描述，是 抽象 的。
  •     对象 是一类事物的实例，是 具体 的。
  •     类是对象的模板，对象是类的实体。 

3.成员变量和局部变量

成员变量(存在于堆内存中，和类一起创建)

局部变量(存在于栈内存中，当方法执行完成，让出内存，让其他方法来使用内存)

4.匿名对象

匿名对象:没有名字的对象

匿名对象的特征：
      语法上: 只创建对象,但是不用变量来接收

      匿名对象的使用:
             1.匿名对象也是一个对象,具有对象的所有功能
             2.每一次使用匿名对象时,都是一个新的对象， 每次创建匿名对象都是不同的对象，一个匿名对象,只能使用一次，即匿名对象只能调用一次

     匿名对象只在堆内存中开辟空间，而不存在栈内存的引用

匿名类（匿名内部类）

     如果要执行的任务需要一个对象，但却不值得创建全新的对象（原因可能是所需的类过于简单，或者是由于它只在一个方法内部使用），匿名类就显得非常有用

如我们需要一个监听类，并且在实例化这个监听类的时候才需要实现这个监听类内部的方法，那么使用匿名类就最方便了

5.封装

将类的某些信息隐藏在类的内部，不允许外部程序访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

6.this关键字

this关键字指向的是当前对象的引用

1. 如果存在同名成员变量与局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。
2. 在一个构造函数中可以调用另外一个构造函数初始化对象。

7.构造方法

1). 构造方法的方法名必须与类名一样。
2). 构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
3). 构造方法不能作用是完成对象的初始化工作，他能够把定义对象时的参数传递给对象的域。
4). 构造方法不能由编程人员调用，而要系统调用。
5). 构造方法可以重载，以参数的个数，类型，或排序顺序区分。

8.继承

继承是类与类的一种关系，例如：动物和狗的关系，动物是父类(或基类)，狗是子类(或派生类)。

要注意的是，在Java中的继承是单继承，也就是说一个儿子只能有一个爸爸

继承的好处：

　　子类拥有父类的所有属性和方法(private除外)

　　子类对父类代码的复用

继承的语法规则：

　　class  子类  extends  父类　　　　#如：　class  Dog extends Animal{　......　　}

方法的重写：

1、什么是方法的重写：

　　如果子类对继承父类的方法不满意，是可以重从写父类继承的方法，当调用时会优先调用子类的方法。

2、语法规则：

　　返回值类型、方法名、参数类型及个数 都要与从父类继承的方法相同，才叫方法的重写。

继承的初始化顺序：

　　若创建一个子类对象，系统会先创建父类的属性进行初始化，再调用父类的构造方法，然后再创建子类的属性进行初始化，最后调用子类的构造方法。

9.多态

多态指对象的多种引用形态，继承是多态的前提

1、引用多态

　　父类的引用可以指向本类对象　　Animal object1=new Animal();

　　父类的引用可以指向子类对象　　Animal object2=new Dog();

　　注意：子类的引用不可以指向父类对象 Dog object3=new Animal();

2、方法多态

　　创建本类对象时，调用的方法为本类的方法；

　　创建子类对象时，调用的为方法为子类重写的方法或者继承的方法

　　注意：本类对象不能调用子类的方法

10.抽象类

1).抽象方法与抽象类必须由abstract修饰符修饰，同时，抽象方法不能拥有方法体；
2).抽象类无法实例化，不能由new来调用抽象类的构造器来创建实例；
3).抽象类可以有①成员变量、②方法（普通方法和抽象方法都可以）、③构造器（不能用于创建实例，限于被子类调用）、④初始化块、⑤内部类（接口、枚举）；
4).含有抽象方法的类只能被定义为抽象类。

11.接口

定义：Java接口（Interface），是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口的特点

1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)

2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化

3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法

4、接口中没有构造方法,不能被实例化

5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口

6、Java接口必须通过类来实现它的抽象方法

7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类

8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例

9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.

12.内部类

可以将一个类的定义放在另一个类的定义内部，这就是内部类。

每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类没有影响。

接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

成员内部类：

public class OuterClass {
    private String name ;
    private int age;

    /**省略getter和setter方法**/
    
    public class InnerClass{
        public InnerClass(){
            name = "chenssy";
            age = 23;
        }
        
        public void display(){
            System.out.println("name：" + getName() +"   ;age：" + getAge());
        }
    }
    
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }
}


--------------
Output：
name：chenssy   ;age：23

局部内部类：

有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

定义在方法里：

public class Parcel5 {
    public Destionation destionation(String str){
        class PDestionation implements Destionation{
            private String label;
            private PDestionation(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return new PDestionation(str);
    }
    
    public static void main(String[] args) {
        Parcel5 parcel5 = new Parcel5();
        Destionation d = parcel5.destionation("chenssy");
    }
}

定义在作用域内:

public class Parcel6 {
    private void internalTracking(boolean b){
        if(b){
            class TrackingSlip{
                private String id;
                TrackingSlip(String s) {
                    id = s;
                }
                String getSlip(){
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("chenssy");
            String string = ts.getSlip();
        }
    }
    
    public void track(){
        internalTracking(true);
    }
    
    public static void main(String[] args) {
        Parcel6 parcel6 = new Parcel6();
        parcel6.track();
    }
}

匿名内部类：

public class OuterClass {
    public InnerClass getInnerClass(final int num,String str2){
        return new InnerClass(){
            int number = num + 3;
            public int getNumber(){
                return number;
            }
        };        /* 注意：分号不能省 */
    }
    
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        InnerClass inner = out.getInnerClass(2, "chenssy");
        System.out.println(inner.getNumber());
    }
}

interface InnerClass {
    int getNumber();
}

四.集合

Collection 接口的接口 对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
│—————-├ ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
│—————-└ Vector 接口实现类 数组， 同步， 线程安全
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口： 仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组）存储元素
│————————└ LinkedHashSet 链表维护元素的插入次序
└ —————-TreeSet 底层实现为二叉树，元素排好序

Map 接口 键值对的集合 （双列集合）
├———Hashtable 接口实现类， 同步， 线程安全
├———HashMap 接口实现类 ，没有同步， 线程不安全-
│—————–├ LinkedHashMap 双向链表和哈希表实现
│—————–└ WeakHashMap
├ ——–TreeMap 红黑树对所有的key进行排序
└———IdentifyHashMap

（1）ArrayList：底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素
（2）LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素
（3）Vector:底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素