初识JAVA

Posted 琳家小美

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了初识JAVA相关的知识,希望对你有一定的参考价值。

1.java的执行顺序

  java(编译) Java(运行)

  编写源码----------->字码文件----------->执行

2.编写源码注意

  a.类名和文件名一致.

  b.括号要成对出现.

3.println和print的区别

  println会换行

  print不会

4.转义字符

  \n 表示换行

  \t 表示空格

5.java注释

  //:单行注释

  /* */:表示多行注释

  /** */表示文本注释

6.java代码规范

  a.类名要用oublic修饰

  b.一行只写一个语句

  c.注意{}的位置

  d.代码层次关系缩进(tab键)

 

变量,数据类型和运算符

2.1变量

  变量:一个数据存储空间表示(代词)

2.2变量的基本语法

  数据类型 变量名 //声明变量=变量值; //赋值

2.3变量的使用

  a.变量必需声明,并且初始化够才能使用.

  b.变量名不能重复.

2.4常见数据类型

  int(整数)

  double(双精度浮点数)

  char(字符)

  String(字符串)

补充:8种基本数据类型

  byte (字节类型)

  short (短整型)

  char (字符型)

  int (整型)

  long (长整型)

  float (单精度浮点型)

  double (双精度浮点型)

  boolean (布尔型)

2.5变量命名规则

  变量名:由数字,字符,下划线,美元符号组成,

  但是不能以数字开头

2.6赋值运算

  变量名=表达式;

2.7算术运算符

  +,-,*(乘),/(除取整),%(取余)

  ++,(自增)等价于 本身= 本身+1

  --,(自减)等价于 本身= 本身-1

2.8类型转换

2.8.1分类

  a.自动类型转换

  b.强制类型转换

2.8.2自动类型转换

  大类型 = 小类型

2.8.3强制类型转换

  小类型 = (小类型)大类型

  注意:强制类型转换是可能会出现溢出

2.9关系运算符

  >(大于),<(小于)

  ==(等于), !=(不等于)

  >=(大于等于) <=(小于等于)

  注意:==表示等于,= 表示:赋值

3.0 boolean类型

  只有true和false两个值

3.1运算符运算优先级

  () > 算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算(=)

  +,-... >, <... ||(或)&&(与)!(非)

 

选择结构

  第一种:

    if(条件){

      //代码块

    }

  解释:如果条件结果为true,那么执行代码块,否则不执行

  第二种:

    if(条件){

      //代码块1

    }else{

      //代码块2

    }

  解释:如果条件结果为true,那么执行代码块1,否则执行代码块2

  第三种

    if(条件){

      //代码块1

    }else if(条件2){

      //代码块2

    }......{

      ...

    }else{

      //代码块n

    }

  解释:如果条件1结果为true,那么执行代码块1

      如果条件1为false,那么将执行下一个条件

      判断,依次重复上面的过程.

注意

  判断字符串是否相同用 str1.equals(str2)

  判断数字相同用num1 == num2

2.switch...case 选择结构

  switch(表达式值){

    case 值1:语句;break;

    case 值2:语句;break;

    .....

    default:语句n;

  }

  解释:如果表达式的值为值1,那么执行语句1,

    如果表达式的值为值2,那么执行语句2,

    ........

    如果表达式从上至下都没有找到匹配到值,那么执行default后面的语句n.

 

注意: 

    1).表达式值可是整型,字符型。jdk1.7以后可以是sting类型

    2).break:表示终止,表达式整个swtich语句结果.

    3).如果匹配到值,并且没有执行break,那么从匹配到那个值的语句

    开始,下面的每一个语句都会执行,知道整个程序结束后者遇到break.

 

 循环结构

1.while循环

  while(条件){

    //代码块

  }

解释:如果条件的结构为true,那么执行代码块

当代码块执行完后,又会执行条件,

依次循环,知道结果为false,整个循环结束.

2.程序调试

  第一步:设置断点(左键双击)

  第二步:debug方式执行代码

  第三步:逐条执行条码调试(f6)

  第四步:检查代码(看变量值的变化)

注意:在右上角可以切换java视图和debug视图.

3.do...while循环

  do{

    //代码块

  }while(条件){
    //代码块

  }  

解释:先执行代码块,然后进行条件判断.

  如果条件为true,那么继续执行代码块

  依次循环,知道条件为false,整个循环结束.

注意

  变量的作用域:从变量声明开始到它所在代码块结束.

4.while和do....while区别

  a.执行顺序不一样

  b.do...while中的循环体至少会执行一次;

  而while中的循环体在结果为false时,不会被执行.

5.for循环

语法:

  for(初始化表达式;条件表达式;循环变量变化表达式){

    //循环体

  }

初始化表达式:用于初始化循环变量值

条件表达式:如果为true则执行循环体,否则退出

循环变量表达式:用于循环变量的控制如i++..

执行顺序:

  第一步:初始化表达式(只会执行一次)

  第二步:条件表达式;如果为true则执行第三步,否则退出循环.

  第三步:循环体

  第四步:循环变量表达式,执行完之后,再执行第二步,依次循环.

注意:

  for循环中三个表达式都可以省略.

  如果第二个表达式没有写,那么它的结果为true.

 

 

数组

1.数组的声明定义

  数组类型[] 变量名 = new 数据类型 [长度];

  例:int [] ary = new int [5];

2.取值,赋值.

  取值:数组名[下标];

  int a = ary [1];

  赋值:变量 = 数组名[下标];

  例:ary [1] = 10;

3.数组的遍历

  数组的长度:数组名.length;

  for(int i=0;i<数组名.length;i++){

    //数组名[i]:访问每个元素的值

  }

4.数组常见的异常

  ArrayIndexOutOfBoundsException     //数组下标越界

  当访问数组的下标超过0~length-1时,就会出现以上错误.

注意:数组下标范围:0~length-1

5.数组的常用方法

  Arrays.toString(数组名);    //展示数组内容

  Arrays.sort(数组名);  //数组按升序排序

6.后序遍历

  for{int i = ary.length-1; i>=0; i--

    ary[i];

  }

7.比较字符串的大小

  如果a.compareToIgnoreCase(b)>0 为true 那么a大于b.

  如果a.compareToIgnoreCase(b)<0 为true 那么a小于b.

  如果a.compareToIgnoreCase(b)==0 为true 那么a等于b.

8.break和continue

  continue:继续(表示结束本轮循环,进入下一个循环)

  break:终止,结束(表示终止当前循环结构)

注意:多层循环,只会对直接的循环起作用

 

类和对象

1.对象和类

  类是对象的抽象,对象是类的具体事例.

例:人是类,小明是对象.

2.创建对象

  语法:类名 对象名 = new 类名();

例:Person p = new Person();

注意:类名也是数据类型.语法也可以写成.

  数据类型 变量名 = new 数据类型();

3.类的语法

  public class 类名 {

    //属性 --->特征

    //方法 --->行为

  }

4.定义属性

  class 类{

    //属性的数据类型 属性名;

    例:int age;//表示年龄

  }

  属性的访问: 对象名.属性名;

  属性的赋值:对象名.属性名 = 值;

5.方法的访问:

  对象名.方法名();

 

无参方法

1.方法的定义

  public 返回值 方法名(){

    //方法体

  }

注意

  如果没有返回值,那么返回值类型是void.

  如果有返回值,那么必须用return 返回值,并且该值的数据类型必须是定义方法

  时的数据类型.

  return的作用:

    a.返回值

    b.结束方法.(与break类似)

 

2.写方法时注意

  第一点:定义void为返回值类型时,不能使用return+返回值.

  第二点:方法不能返回多个值.

  第三点:方法不能嵌套.

  第四点:不能在方法外部直接写程序逻辑代码.

3.成员变量和局部变量的区别

  a.作用域不同

    局部变量的作用域仅限于定义它的方法

    成员变量的作用域在整个类内部都是可见的

  b.初始值不同

    java会给成员变量一个初始值

    java不会给局部变量赋予初始值

注意

  a.相同的方法中,局部变量名不能重复

  b.不同方法中,局部变量名可以重复

  c.同一个类中,成员变量名和局部变量可以相同,一般以局部变量为准.(就近原则)

4.java.lang.NullpointerException(空指针异常)

  原因:对象的值为null,并且对次对象进行了操作.

  解决方案:找到次对象的数据来源,查看到new对象的代码

  是否执行或是否编写,根据不同的原因去解决问题.

注意: 

  写任何代码

  第一点代码的执行过程.

  第二点:值来自于哪里.

建议

  1.别先写代码,先写步骤.

  2.不要关注实现细节

 

有参方法

1.方法的定义

  public 返回值类型 方法名(参数类型1,参数名1,参数类型2,参数名2,.....参数类型n){

    //方法体

  }

2.有参数的调用

  a.如果同一个类中,方法可以直接调用.

  b.如果不同的类,方法必须通过对象调用,

  对象名.方法名(实参,实参2...)

注意

  1)实参的数据类型,参数的个数,参数的顺序要跟形象保持一致.

  2)调用有返回值的方法,一般要接受返回值,并作出相应的处理.

3.包

  a.包:文件夹(从src目录下开始算起)

    例:oo.day01

  b.包命名规范

    包由小写字母组成,不能以圆点开头或结尾.

  c.当使用不同包中的类时,必须用import将这个类导入到

  指定的类中,(如果是同一个包中的类,不需要import,java会自动导入).

 

4.字符串(String)的定义

  String str = “内容”

  String str = new String();  //内容为null

  String str = new String(“内容”);

5.java.lang.*

  字符串所在的包是java.lang.

注意:所有在java.lang包下的类,我们使用时,不需要import.

6.常用方法

  str.length();  //字符串的长度

  str.indexOf(str1);  //子串str1出现的下标.(从前往后找).

  str.lastIndexOf(str1);  //子串str1出现的下标(从后往前找).

  str.substring(begin);  //截取从下标begin开始到末尾的子串.

  str.substring(begin,end);  //截取从下标begin开始到下标end的子串.

  str.trim();  //去掉首尾空白

  str.toLowerCase();  //返回字符串的小写

  str.toUpperCase();  //返回字符串大写

 

7.从现实抽象出类的步骤

  第一:找出分类(分析出类)

  第二:找出类的特征(分析类的相关属性)

  第三:找出类的行为(分析类的方法)

8.常量(经常出现的变量值)

  语法:public static final 数据类型 变量名 = 变量值;

注意

  变量名的所有字母都大写,多个单词用下划线(_)分割.

例:public static final String SEX_MALE=“Q仔”;

常量的访问方式

  类名.常量名;

 

构造方法(特殊方法,用来创建对象 没写就会默认有构造方法)

1.语法

  public 类名 (参数列表){

      //方法体

  }

2使用

  类名 对象 new 构造方法名(参数);

例: Dog d = new Dog();

3 构造方法的作用

  a.创建对象.

  b.初始化值(属性值)

4构造方法和普通方法的区别:

  a.构造方法没有返回值类型(return....)

  b.构造方法的方法名就是类名,普通方法可以任意取.

  c.构造方法的调用:new 构造方法名(参数)

  普通方法的调用:对象名.方法名(参数)

注意:当你没有写构造函数时,java会提供默认的无参构造函数.

例:

  public Dog{

  }

 

方法重载

1.方法重载

  方法名一样,参数列表不一样.

注意:重载与返回值类型和访问修饰符无关.

 

2.static和final

  static:静态的

    用static修饰的属性,直接可以类名.方法名访问

  final:最终的

    用final修饰的属性,它的值初始化后,不能再改变

注意:static不能再方法中修饰局部变量

补充:

  后++,先把本身的值作为表达式的值,然后本身+1;

  例:i++

  前++,先本身加1,然后再把值作为表达式的值;

  例:++i

  后-- 先把本身的值作为表达式的值,然后本身-1;

  例:i--

  前-- 先本身-1,然后再把值作为表达式的值;

  例:--i

 

封装

1.封装:隐藏类内部细节

2.封装 步骤

  第一步:将属性私有化.(private)

  第二步:提供getter/setter方法(getXxxx(),setXxxx()).

  第三步:在getter/setter中加入控制语句.

3. this关键词

  this:表示当前对象.

  调用属性:this.属性名

  调用方法:this.方法名();

  this():表示调用构造函数.

注意:this(),必需写在构造函数的第一行.

 

继承(extends)

1. 继承:遗传

2. 语法

  public class 子类 extends 父类{

    //代码块

  }

例:public class Dog extends Pet {

    //代码块

}

3. 继承的特点

  a.子类可以继承父类的非私有的属性和方法

  b.不能继承构造方法

  c.继承默认权限修饰符的方法和属性,子类和父类必需在同一包中

4. super(父类)

  super.属性名; //表示访问父类的属性

  super.方法名(参数); //表示访问父类的方法

  super(参数);//表示访问父类的构造函数;

注意:super()访问父类构造函数时,必需写在第一行;

 

抽象类(abstract)

1. 抽象类

  语法:public abstract class 类名(){};

2. 抽象方法

  语法:public abstract 返回值类型 方法名(参数列表);

  例:public abstract void print();

注意:抽象方法有abstract修饰,并且抽象方法没有方法体.

3. 抽象类和抽象方法的特点

  a.都用abstract修饰

  b.抽象方法没有方法体

  c.抽象类不能实例化,并且继承必需重写抽象类中的所有抽象方法

注意

  1.抽象类中不一定有抽象方法

  2.含有抽象类方法的类,一定是抽象类(接口)

 

重写

1. 重写就是子类重写定义父类的方法

2. 重写规则

  a.方法名和参数列表相同.

  b.修饰符访问权限子类和父类相同或者比父类大.

  c.返回值类型子类和父类相同或者是父类的返回值类型的子类

  d.异常跟父类相同或者范围更小

重写时

  子类的东西都要与父类保持一致

方法重写

  位置相同,方法名相同,参数列表相同,返回值相同或是其子类,访问修饰符不能比父类严格

方法重载:位置同类,方法名相同,参数列表不相同,返回值无关,访问修饰符无关

 

final

  final修饰的类不能被继承

  final修饰的方法不能重写

  final修饰的属性不能被修改

 

多态

1. 多态含义:一个事物的多种形态

2. 多态的表现

  行为(方法)多态:重写和重载.

  引用多态(动态绑定):编译时的类型和运行时不一致的这种现象叫做动态绑定.

  例:父类 = 子类.

    pet p = new Dog();

3.向上转型和向下转型

  向上转型:父类 = 子类;

  向下转型:子类 = (子类)父类;

  例:Dog d = Dog()p;

注意java.lang.ClassCastException:类型转换异常.

    父类的运行时类型跟要转成的子类的类型不一致

注意:引用多态存在继承关系

 

instanceof

  语法:对象A instanceof 类型B;

  判断对象A的类型是否是类型B,如果是就返回true,否则返回false.

  例:d instanceof Dog

 

实现多态的两种形式

  a.使用父类作为方法形参实现多态

    public void play(Pet p){}

  b.使用父类作为方法返回值实现多态

    public Pet getPet(int type){}

 

接口

1. 语法

  public interface 接口名 extends 接口1,接口2..{

      //1.常量

      //2.抽象方法

  }

2.特点

  a.用interface修饰

  b.接口可以继承接口,多继承

  c.接口内只能定义常量和抽象方法

  d.接口不能实例化,但是可以作为子类的引用

  e.实现接口的子类都必需实现它的所有抽象方法

 

foreach循环和...

  ... :形参里面出现,表示的是可变参数

  foreach循环:

    语法:for(int 下标 = 0;i < 数组的长度;i++){ 数组元素值 数组[i]}

    语法:for(数组元素类型 数组的元素值:数组){}

 

异常

1.异常:程序执行过程中出现的影响程序正常运行的现象.

2.异常语法

  try{

    //代码块

  }catch(异常类型 e){

    //代码块

  }catch(异常类型 2 e2){

    //代码块

  }...{

    //代码块

  }finally{

    //代码块

  }

注意

  try:表示可能出现异常的代码块.

  catch:抓取异常,并进行处理,可以抓取多个异常,

      异常的范围要从小到大抓取,并且只会执行第一个匹配的异常类型.

  finally:最终的,不管是否出现异常,finally中的代码块始终会执行.

      除虚拟机停止(System.exit(1))这种情况外.

注意

  finally 和 return的执行顺序:

      先执行return,把返回结果保存在返回结果区域,并没有返回,再执行finally,

      最后,把保存在结果区域的结果返回给调用者.  

3.throws声明异常

  a.就是当前方法,不能解决这个异常的时候,必须把这个异常交给上一个调用者去处理.

  b.语法

    访问修饰符 返回值类型 方法名(参数列表)[throws 异常]{}

 

java异常体系

Throwable

   error: (出现不能通过的程序处理的错误)

  Exception:可以同程序抓取或者抛出的错误.

  检查异常(非运行时异常):编译阶段会出现的异常

    SqlException,

    IOException,

    ClassNotFoundException

  非检查异常(运行时异常RunTimeE)

    NullPointerException,

    ArrayIndexOfBoundsException,

    ClassCastException,

注意

  checked异常,是必需处理的

  运行时异常,可以不处理

 

导入第三方jar包

  第一步:右击工程名,新建一个文件夹(Fold),名字为lib.

  第二步:把第三方jar包复制到lib目录下.

  第三步:右击工程名---->properties

      ---->java build path

      ---->libraries

      ---->add jar

      ---->再从项目的lib目录下选中你要的jar包

      ---->确定.

 

使用log4j

  第一步:导入log4j jar包

  第二步:写配置文件

注意

  文件名和文件路径

  (开发)(生成)

  log4j.rootLogger=debug | info

  第三步:使用log4j

  a.导入log4j类

    import org.apache.log4j.Logger;

  b.在指定类中,写属性

  private static Logger logger = Logger.getLogger(指定类名.class);

  c.在指定行写日志

  logger.debug("日志信息");

  logger.info("信息");

 

集合框架

  Collection Map

  List Set HashMap

  ArrayList LinkedList HashSet

1. List的方法

  List<元素类型> list = new LinkedList<元素类型>();

  list.add(元素);  //增加元素

  list.add(index,元素);  //向指定位置插入元素

  list.remove(下标);  //删除指定下标的元素

  list.remove(元素);  //删除指定元素

  list.get(index);  //获取指定下标元素

  list.contains(元素);  //集合中是否包含指定元素

2. Collection,List,Set的区别

  Collection:不唯一,无序

  List:不唯一,有序

  Set:唯一,无序

3 .ArrayList和LinkedList的区别

  a.都实现了List

  b.ArrayList是可边长数组方式实现,查询效率高.

    LinkedList是链表方式实现,增加和删除效率高.

4. List常用方法

  List <Object> list = new ArrayList<Object>();

  list.add(Obj);  //增加元素

  list.get(下标);  //获取指定下标元素

  list.size();    //长度

  list.remove(Obj);  //删除指定元素

  list.contains(Obj);  //是否包含指定元素

5 .Map 常用方法(键值对方式存储数据)

  Map<Object,Object> maps = new HashMap<Object,Object>();

  maps.put(key,value);  //增加元素

  maps.get(key);  //获取指定key的值

  maps.size();  //长度

  maps.remove(key);  //删除指定元素

  maps.containsKey(key);  //是否包含指定key

注意

  key是唯一的,如果重复那么后面的会覆盖前面的.

  value是可以重复的.

6. Vector和ArrayList的异同

  实现原理、功能相同、可以互用

  Vector线程安全,ArrayList重速度轻安全,线程非安全

  长度需增长时,Vector默认增长一倍,ArrayList增长50%

  Hashtable和HashMap的异同

  Hashtable继承Dictionary类,HashMap实现Map接口

  Hashtable线程安全,HashMap线程非安全

  Hashtable不允许null值,HashMap允许null值


以上是关于初识JAVA的主要内容,如果未能解决你的问题,请参考以下文章

初识Java

JavaSE初识Java语言

JSP之初识

一初识java

java复习--初识java

初识Java