java基础语法,java语法

从零开始学习java(一)java基础语法,从零开始java

  从公司裸辞一个月,原本工作是做VB的,现在想从事java;在找工作的时候总是要什么项目经验,多少有些不爽,所有语言都有共

通性,我就不信java有这么难?给自己点时间来学习。坚持一个月自学,看看自己的努力究竟有多少用。本次学习从《java核心技术》

第9版开始,每读一章写一篇文章,如果写的不对的话,请指教。

  “像Java这种功能强大的语言大都不太容易学习”,第一章开头就给我一个下马威。。。你既然这样说,那我就学给你看!第一二章是

讲java的概念,发展的,就此跳过!

     1.helloworld 

  按照惯例,学习一门语言的开始,简单的程序:hellowrold;java
类名以大写开头,多个字母首字母大写。class 代表一个类,java的

基础就是由类组成,类里面包含属性和方法。main方法和C语言的main方法一样,是每个程序运行的入口;每个类只能有一个class是

public的。另外java代码每句话结束时以分号结束;

图片 1

1 public class HelloWorld {
2     
3     public static void main(String[] args) {
4          
5         System.out.println("HelloWorld");
6     }

View Code

  2.数据类型

  整形:byte:1字节;(1字节8个二进制 00000000 ,范围:-2^8
to 2^8-1 )short:2字节 int :4字节; long  8字节;

     浮点类型:用于表示带有小数点的类型; float:4字节 ;double :8
字节; 

     char类型:char :单字符类型;“A”,”a”等,还有转义字符“/n”换行等;

  boolean类型: FALSE  true ;真和假!

  3.变量

   在java中每个变量属于一个类型(type),类型在变量之前。例如 int
i;同时每个变量必须赋初始值,不然在用到变量的时候

会报错;

  4.运算符

  + – * / %:加减乘除取余数; ++,– 自增自减运算符;& 与 ,|
或,~非,^异或 ; &&与,||或;

  5.强制类型转换

  例如double转int型,后面的小数位可能就没有了,编译器就认为有错;这时候就需要强制转换了,例如:
int i=(int) 4.3;

  6.字符串String类

  

  @Test
    /**
     * 测试String常用方法;String是由数组进行实现的,因此修改一个String相当于新建一个String
     */
    public void testString(){

        String s="hello ";
        //判断是否为空
        System.out.println(s.isEmpty());
        //判断字符串是否相等
        System.out.println(s.equals("Hello"));
        //判断字符串是否相等,不区分大小写
        System.out.println(s.equalsIgnoreCase("Hello"));
        //返回下标为1的字符串
        System.out.println(s.charAt(1));
        //返回字符串的长度
        System.out.println(s.length());
        //字母全部大写
        System.out.println(s.toUpperCase());
        //字母全部小写
        System.out.println(s.toLowerCase());
        //去除开头或者结尾的字符串
        System.out.println(s.trim());
        //截取字符串从下标开头到结尾-1截取
        System.out.println(s.substring(1,3));

    }

    

  7.控制语句

  

图片 2

@Test
    public void testControl(){
        int i = 0 ;

        for(;i<10;i++){
            System.out.println(i);
        }
        while(i>0){
            System.out.println(i--);
        }
        if(i>0){
            System.out.println("i>0");
        }else{
            System.out.println("i<=0");
        }
        switch(i) {
            case 0:
                System.out.println("switch:"+i);
                break;//如果不加break将顺序执行下去
            case 1:
                System.out.println("switch:"+i);
                break;
            default:
                System.out.println(i);
                break;
        }

    }

View Code

 

  8.数组

图片 3

@Test
    public void testArray(){
         int a[]={6,4,7,6,3,8,9};

         //foreach循环
         for(int j:a){
             System.out.println(j);
         }
         Arrays.sort(a);//数组排序,利用的快速排序法
         int b[]=Arrays.copyOf(a, a.length);
         for(int j:b){
              System.out.println("copy"+j);
          }
    } 

View Code

 

  

从公司裸辞一个月,原本工作是做VB的,现在想从事java;在找工作的时候总是要什么项目…

java语法基础一,java语法基础

Java语法基础一

  • Java代码基本格式

Java中所有程序代码都必须存在于一个类中,用class关键字定义类,在class之前可以有一些修饰符。格式如下:

修饰符 class 类名

{

程序代码

}

注:1、Java是严格区分大小写的。 

2、Java程序中一句连续的字符串不能分开在两行中写。

  •  Java程序的注释

Java里的注释有三种类型:图片 4

1、单行注释

在注释内容前面加“//”,格式为:                                                  

代码; //注释内容

2、多行注释

以斜杠加星号开头,以星号加斜杠结尾。

3、文档注释

以斜杠加两个星号开头,以一个星号加斜杠结束。

用这种方法注释的内容会被解释成程序的正式文档,并能包含进诸如javadoc之类的工具程序生成的文档里,用以说明该程序的层次结构及其方法。

  • Java中的标识符

Java中的包、类、方法、参数、变量的名字,可以由任意顺序的大小写字母、数字、下划线(_)、美元符号($)组成,但不能以数字开头,不能是Java中的保留关键字。

备注:Java中的包、类、方法、参数、变量的名字写的时候建议采用驼峰型。如:HelloWorld

  • Java的关键字

1、用于类和接口的声明:class, extends, implements, interface

2、包引入和包声明:import, package

3、数据类型:byte, boolean, char, double, int, long, float, short

4、某些数据类型的字面量值:flase, ture, null

5、流程控制:break, case, continue, default, do, else, for, if, return,
switch, while

6、异常处理:catch, finally, throw, throws, try

7、修饰符:abstract, final, native, private, protected, public, static,
synchronilzed, transient, volatitle

8、操作符:instanceof

9、创建对象: new

10、引用:this, supper

11、方法返回类型:void

12、保留字:const, goto

  • Java的数据类型:

1.Java的基础数据类型语下层操作系统或平台没有关系,数字值都是有符号的,既以

存储正数也可以存储负数,char类型是16位,并没有符号,boolean类型只能包含

true和false这两个值。

2.整型字面量值均默认为int类型,若要使用long类型,就必须在其末尾加L或l,

浮点型字面量值均默认为double类型,若要用float类型,就必须在其末尾加F或f。

3.引用不包含它所指的对象的实际数据,而是指向内存中对象所在的位置,且对象则

包含实际数据,java中,引用要么指向一个对象,要么指向null。这也正是java的

安全特性之一:不允许程序员直接访问内存。

常用的转义字符有:

\r——表示接受键盘输入,相当于按了一下回车键                          
图片 5

\n——表示换行

\t——表示制表符,相当于Tab键

\b——表示退格键,相当于Back Space键

\’——表示单引号

\”——表示双引号

\\——表示反斜杠“\”

Java 语法基础一 Java
代码基本格式
Java中所有程序代码都必须存在于一个类中,用class关键字定义类,在class之…

学习内容来
自菜鸟教程    
Java基础

java基础语法,java语法

java基础之基础语法详录,java语法

前言

java的语法先从基础语法学,Java语言是由对象组成的,其对象和类又是由方法变量组成,而方法,又包含了语句表达式

  • 对象:(几乎)一切都是对象,比如:一只熊猫,他的外观,颜色,他在吃、喝、睡、玩
  • :如果说一切都是对象,那么什么决定了某一类对象的外观和行为呢?类是一个模板,它描述一类对象的行为和状态。
  • class HelloWorld{/这表示一个类,class后跟的是类名/}

  • 方法:(方法也可以称作成员函数)方法你可以看成是行为,一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。

  • 变量:每个对象都有独特的实例变量,对象的状态由这些实例变量的值决定。

 

第一个java程序

public class HelloWolrd {
    /**
     * 第一个Java程序
     */
    public static void main(String[] args) {
        // 打印Hello World
        System.out.println("Hello World");
    }

}

 

说一下保存,编译,运行这个程序

   图片 6

  2. 打开dos窗口,找到你保存的位置(比如:我的位置是D:\HelloWorld)

   图片 7

  3. 切换盘符到你的文件存放目录 

   图片 8

  4. 输入 javac HelloWorld.java
回车,这时HelloWorld文件夹中应该多了一个HelloWorld.class文件,这就编译了这段代码

   图片 9

   图片 10

  5. 再次输入java HelloWorld 打印出Hello World

   图片 11

 

基本语法

 1. 区分大小写:大小写是敏感的,比如HelloWorld与helloworld是不同的

 2.
类名:java的类名首字母必须大写,且类名像UserNameManage这种多个字母组成的,则每个单词的首字母应该大写,俗称”驼峰命名法”中的大驼峰命名法(即:帕斯卡命名法)

 3. 方法名:一个单词则小写
例如:user,多个单词首字母小写,从第二个单词开始,每个单词首字母大写
例如:userNameManage(小驼峰命名法)

 4. 关键字:都是小写的 例如:public

 5. 常量: 全部大写 例如:PI

 6. 变量:规则同方法命名一样

 7. : 全部小写

 

【java标识符】

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

 1. 只能使用字母、数字、下划线和美元符。

 2. 只能以字母、下划线和美元符开头。也就是不能以数字开头。 

 3. 严格区分大小写,没有长度限制。建议不要太长。

 4. 应该具有特定的意义,关键字不可以用作标识符。

 

  Java:一个Java程序可以认为是一系列的对象组合,而这些对象通过调用彼此的方法来协同工作。

一 规则

1 命名规则 
A:类名称首字母大写,尽可能采取驼峰式命名:MaLin HelloWorld 
B:命名标识符规范:数字、字母、下划线、$组成,但是不能以数字开头,不能是关键字或者保留字。例如:3max
3d goto 
C:变量名称 :首字母必须小写 常量:必须全大些 PI MAX 
D: 方法名称:首字母必须小写 
2 严格区分大小写 
3 以分号 ‘;’ 结束

java修饰符】

Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符:

  • 访问控制修饰符 : default, public , protected, private
  • 非访问控制修饰符 : final, abstract, strictfp

 

  对像:对象是一个类的实例,有状态和行为。例如:
一条狗是个对象,他的状态:“颜色”、“名字”、“品种”,他的行为:“叫”等

二 数据类型

A:基本数据类型(四类八种) 
1. 简单类型 
图片 12 
2. 封装类型(数据类型转换简单类型) 
Byte Short Integer Long Float Double Character Boolean 
1.基本类型只能按值传递,而每个基本类型对应的封装类是按引用传递的。 
2.从性能上说java中的基本类型是在堆栈上创建的,而所有的对象类型都是在堆上创建的,(对象的引用在堆栈上创建) 
B:引用类型 
1.数组 2.类(对象) 3.接口

说明: 
机器语言(二进制语言):由 1 、 0 构成。 例如: 00000101 
最小单位:bit 位 8bit = 1byte(字节、字符) ‘a’~’z’ ‘A’~’Z’ ‘0’~’9’
特殊符号 一个中文汉字=2个字节=16位 ‘好’ 
1024byte = 1KB 1024kb = 1mb 1024mb = 1gb 1024gb = 1tb 
包:本质文件夹目录 
java.lang.* 1.java默认导入 
java.util.*; 1.工具类 
java.sql.*; 1.数据库 
java.net.*; 1.网络编程 
java.io.*; 1.输入输出流 
导包快捷键 ctrl+shift+o

package com.companyname.test;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
    }
}

java分隔符】

  • 具有:空格、圆括号、花括号、分号等。 
  • 每条语句无论一行还是多行都以分号结束。块(Block)是包含在{}里面的多条语句,块可以嵌套。空白插在代码的元素中间:由一个或多个空格组成,也可以由一个或多个tab空格组成多个空行。

【java注释】

 写程序注释是必不可少的一部分。做规范,显条理,对于以后的开发带来了方便。

 

public class HelloWorld {

    /**
     * @param args
     * 第一个Java程序
     * 这是文档注释
     */
    public static void main(String[] args) {
        /*
         * 这是多行注释
         */
        System.out.println("Hello World");
        // 打印Hello World(这是一个单行的注释)
        System.out.println("Hello World");
    }

}

  类:   类是一个模板,他描述一类对象的行为和状态 。例如:狗类

三 变量、常量

1 语法: 
数据类型 变量名称 [= 值];

char sex; //声明变量
        sex = '男';//初始化、赋值 
        int age = 10; 
        float score = 93.2F; 
        int x,y,z=20;

final 数据类型 变量名称 [= 值]; final int X=1; 
1.先声明 2.初始化 3.使用

2 类型之间的转换: 
2.1小——>大:自动类型转换

short  y = 1;
System.out.println(y);
double x =  y;

System.out.println(x);—>小: 强制类型转换

at score = 13;//13(int)-->小,到
         System.out.println(score);
         int rs = (int)score; // 0.3截取丢失
         System.out.println(rs);

图片 13

 

  方法:方法就是行为,一个类可以有很多的方法,逻辑运算、数据修改、以及所有动作都在方法中完成。

四 字符串类型

String在java.lang.String 
1.必须掌握: = = 、 equals() 字符串比较差别

public class Test1 {
    public static void main(String[] args) {
//       String:特殊java类
         int    num  =  100;
         String name = "jackson";
         String address = "北大街西华门....";
         String phone = "18182679850";

         System.out.println(name+address);//字符串的拼接
         System.out.println(3.14f+name);//任何类型+字符串=字符串
         System.out.println("520"+"张三");


         String temp = "jackson";
         String str1 = new String("jackson");//占内存
         System.out.println(str1); 
    }
}

2.熟练进行 简单类型字符串类型 
String.valueOf(参数) 任意类型+”” 
字符串简单类型(封装类型:parseXxx())

public class Test2 {
    public static void main(String[] args) {
        float num = 3.1f;
        String str = String.valueOf(num);
        System.out.println(str);//3.1(String)
        num =  Float.parseFloat(str) ;
    }
}

3.掌握:String类中常用功能 
图片 14 
图片 15 
图片 16 
频繁的操作字符串:不建议使用String类,而是使用StringBuilder &
StringBuffer

【java关键字】

关键字

含义

Abstract

用在类的声明中来指明一个类是不能被实例化的,但是可以被其它类继承。一个抽象类可以使用抽象方法,抽象方法不需要实现,但是需要在子类中被实现

Boolean

布尔类型,只有true或者false

Break

停止,并跳出本层循环

Byte

8bit (位),也就是8个1/0表示,即二进制

Case

用来定义一组分支选择,如果某个值和switch中给出的值一样,就会从该分支开始执行。

Catch

用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。

Char

用来定义一个字符类型

Class

Const

在Java中,const是作为保留字以备扩充,同样的保留字以备扩充还有goto.你可以用final关键字.final也可以用于声明方法或类,被声明为final的方法或类不能被继承。一般C里是const 对应java用final

Continue

用来打断当前循环过程,从当前循环的最后重新开始执行,如果后面跟有一个标签,则从标签对应的地方开始执行。

Default

配合switch跟case使用,但case中没有找到匹配时,则输出或者为default后面的语句。

Do

用来声明一个循环,这个循环的结束条件可以通过while关键字设置

Double

用来定义一个double类型的变量

Else

如果if语句的条件不满足就会执行该语句。

Extends

extends 继承 类X 通过extend 类Y来添加功能,或者添加变量,或者添加方法,或者覆盖类Y的方法。一个接口extends另外一个接口来添加方法。

False

假的

Final

一个Java语言的关键字。你只能定义一个实体一次,以后不能改变它或继承它。更严格的讲:一个final修饰的类不能被子类化,一个final修饰的方法不能被重写,一个final修饰的变量不能改变其初始值。

Finally

用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。

Float

用来定义一个浮点数变量

For

用来声明一个循环。程序员可以指定要循环的语句,推出条件和初始化变量。

Goto

虽然为Java关键字,但是仅在C语言里面使用,Java不提供Goto语句

If

Java编程语言的一个关键字,用来生成一个条件测试,如果条件为真,就执行if下的语句。

Implements

Java(TM)编程语言的一个关键字,在类的声明中是可选的,用来指明当前类实现的接口。

Import

Java(TM)编程语言的一个关键字,在源文件的开始部分指明后面将要引用的一个类或整个包,这样就不必在使用的时候加上包的名字。

Instaceof

一个二操作数的Java(TM)语言关键字,用来测试第一个参数的运行时类型是否和第二个参数兼容。

Int

Java(TM)的一个关键字,用来定义一个整形变量

Interface

Java(TM)的一个关键字,用来定义一系列的方法和常量。它可以被类实现,通过implements关键字。

Long

用来定义一个long类型的变量

Native

本地方法。

New

用来创建一个新的方法

Null

当String类型没赋值时,该变量的值为Null

Package

包的意思

Private

用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。

Protected

在方法和变量的声明中使用,它表示这个方法或变量只能被同一个类中的,子类中的或者同一个包中的类中的元素所访问。

Public

在方法和变量的声明中使用,它表示这个方法或变量能够被其它类中的元素访问。

Return

用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。

Short

用来定义一个short类型的变量。

Static

用来定义一个变量为类变量。类只维护一个类变量的拷贝,不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。类方法通过类名调用而不是特定的实例,并且只能操作类变量。

Super

父类

Switch

是一个选择语句,与case,default,break一起使用。

Synchronized

线程同步

This

用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。

Threadsafe

   

Throw

允许用户抛出一个exception对象或者任何实现throwable的对象

Throws

用在方法的声明中来说明哪些异常这个方法是不处理的,而是提交到程序的更高一层。

Transient

用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候,transient型变量的值不包括在串行化的表示中,然而非transient型的变量是被包括进去的。

True

真的

Try

用来定义一个可能抛出异常语句块。如果一个异常被抛出,一个可选的catch语句块会处理try语句块中抛出的异常。同时,一个finally语句块会被执行,无论一个异常是否被抛出。

Void

用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。

volatile

用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。

while

用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。

 

【 前言 】
java的语法先从基础语法学,Java语言是由 类 和 对象
组成的,其对象和类又是由 方法 和 变量…

  实例变量:
每个对象都有独特的实例变量。对象的状态由这些实例变量的值决定。

五 运算符

1 算术运算符 
双目: * / %(取余、求模) + – 
单目: ++ – 
a 前缀(num++;)

int num = 4;
        ++num;
        int rs = ++num*2;
        System.out.println(rs);//?

b 后缀

int num = 4;
        int x = 3;
        num++;//5
        int rs = num++ +x; //rs = 8  num=6
        System.out.println(rs++);//?
        System.out.println(rs);

2 关系运算符:true/false

< >= <= ==(恒等于) != 
逻辑运算符:true/false 
!(取反) &&(短路且) ||(短路或)

int x=3,y=4,z=10;
boolean rs = x>y&&++z>10;// true / false
System.out.println(z);

算符 = 
3 赋值运算符 
赋值运算符: = 
复合赋值运算符: += -= *= /= %=

int x = 5;
//      x = x + 10;
        x+=10;
        System.out.println(x);

4 三目运算符: 
exp1 ? exp2 : exp3; 
exp1:true exp2; 
exp1:false exp3; 
5 位运算符: 
~ 非 |或 &与 ^异或 
按位~运算符:10100101=01011010 
按位&运算符:1101&1010=1000 
按位|运算符: 1101 | 1010= 1111 
按位异或运算符:1101 ^ 1010 = 0111 
6 位移运算符 
<< 3<<3=24 >> 
在数字没有溢出的前提下,对于正数和负数,左移一位都相当于乘以2的1次方,左移n位就相当于乘以2的n次方 
7 转义字符: 
\n 换行 
\r 回车 
\t 水平制表 
\v 垂直 制表 
\” “ 
\’ ‘ 
\ \

一 规则 1 命名规则
A:类名称首字母大写,尽可能采取驼峰式命名:MaLin HelloWorld
B:命名标识符规范:数字、字母、下划…

Java基础语法:

  大小写敏感:

  类名:对所有的类来说,类名的首字母应该大写。

  方法名:所有的方法名首字母都应该小写。

  源文件:源文件名必须和类名相同。

  主入口方法:所有的Java程序由public static void main(string []
args)方法开始执行

Java标识符

  所有的标识符必须以字母、数字、下划线( “_”
)、美元符号(”$”)组成,且数字不能做开头。
  标识符大小写敏感,且不能是关键字

Java修饰符

  向其他语言一样,Java可以使用修饰符,来修饰类中的方法很属性。

  访问控制修饰符:default、public、protected、private

  非访问控制修饰符:final、abstract、strivtfp

Java变量:

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

  类变量(静态变量):类变量也声明在类中,方法体之外,但必须声明为static类型。

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

Java枚举

  枚举限定变量只能是预先设定好的值,

继承:

  在Java中一个类可以由其他类派生,如果你要创建一个类,而且已经存在一个类具有你所需要的属性和方法,那么你可以将新创建的类继承该类

  利用继承的方法,可以重用已存在的类的方法和属性,而不用重写这些代码,被继承的类称为超类(super
class) ,派生类称为子类(sub class) 

 构造方法

  每个类都有构造方法,如果没有显示的为类定义构造方法,Java编译器会为该类提供一个默认的构造方法。

  在创建一个对象的时候,至少要调用一个构造方法,构造方法的名称必须与类同名,一个类可以有多个构造方法。

public class Puppy{
    public Puppy(){
    }

    public Puppy(String name){
        // 这个构造器仅有一个参数:name
    }
}

创建对象:

  对象是根据类创建的,在Java中使用关键字new
来创建一个对象,创建对象的过程需要三步

  声明:声明一个对象包括对象的名称和类型

  实例化:使用new 来创建一个对象

  初始化:使用new创建对象时,会调用构造方法初始化对象

  

public class Puppy{
   public Puppy(String name){  
     //初始化对象
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
      //-----------     -------------
      //     声明            实例化       
   } 
}

 

相关文章