java中的类介绍

代码的结果

  (1)外层框架

    public class HelloWorld {     //HelloWorld叫作类的名称(类名)

     }

   公共的类名必须与文件名同名

public class HelloWorld{

}

class Hello{

}

 

class World{

 

 

}

一个文件中可以有N多个class,只能有一个为 public ,文件名必须与 public 的类名相同

HelloWorld与Hello,World这三个类的关系为 并列关系.

public class Test{

       public class A{       

       }

}

Test称为外部类,A称为内部类，二者之间的关系为嵌套

(2)执行入口

public static void main(String [] args){       

}

(3)标准的输出设备上打印一句话

System.out   :标准的输出设备

println()        :打印输出后换后

System.out.println("helloworld");

 

案例1:

public class HelloWorld{

       public static void main(String [] args){

                System.out.println("helloworld");

       }

 

}

class Hello{

       public static void main(String [] args){

                System.out.println("hello");

       }

 

}

 

class World{

       public static void main(String [] args){

                System.out.println("world");

       }

 

}

执行时,  java   Hello

            java    World

            java   HelloWorld

总结：使用记事本开发Java程序的步骤?

      (1) 编写 源文件     (程序员)

      (2) 编译 源文件     (javac )

      (3) 执行 字节码文件   (java )

 

 注释：对程序的解释说明

    (1)单行注释  ：   //  

                 作用：为一句代码进行解释说明

    (2)多行注释   :    /*开头   ,*/结尾

                 作用:对代码进行解释说明

    (3)文档注释(doc注释) :   /**开头，   */结尾

                 作用: 生成API帮助文档

                           对类及方法的功能描述

                  位置: 类名上方，方法名上方

 

2.2变量与数据类型

 

数据类型：根据存储方式不同分两类  

                 (1)基本数据类型(8大基本数据类型) (使用一块内存存储,存储的是变量的 值 )

                     整数: byte,short,int,long

                     浮点数:float ,double

                     字符:char

                     布尔型：boolean

                 (2)引用数据类型 (使用两块内存存储，一块存 值 ，一块存 地址 )

                       类 (举例:String)

                       接口

                       数组

 

栈内存  :基本数据类型的 值 和引用数据类型的 地址

堆内存  :引用数据类型的 值(数据)

 

整数:

public class Test{

       public static void main(String [] args){

               //int a=Integer.MAX_VALUE+1;

               //System.out.println(a);

               /*十进制整型*/

               byte a=123;

               short s=123;

               int i=123;

               long b=123L;

                /*以0开头的为八进制整数,  范围0-7*/

               int k=017;

               System.out.println(k);

                /*以0x开头的为十六进制,0-9,A-F*/

               int j=0x1a;

               System.out.println(j);

       }

}

 

总结：

数值型: byte(1个字节-128到127之间) ,short(2个字节),int(默认，4个字节),long(8个字节l/L),

            float(4个字节,f/F),double(默认,d/D)

字符: char (2个字节)  a-->97,A-->65,大小写之间相差32

布尔型  boolean(1位)值，只有两个true，false

数据类型是固定的（基本和引用）

变量名:自己起的的

值: 可以变化的量

 

2.3变量的使用

案例2:

public class TestMoney{

       public static void main(String [] args){

                //[1]声明，跟内存打招呼

               int money ;  //在内存中开辟了一块空间，空间的名称为money

               //[2]赋值，将数据放到内存中存储

                money =1000;

               //[3]使用,根据"变量名"获取内存中所存储的数据

               System.out.println( money );     //输出结果为1000

               System.out.println("money");  //输出结果为money

       }

}

内存图

变量的使用步骤:

[1]声明变量:    数据类型     变量名;

                      int age;

                      String name;

                      double salary;

                      char sex;

                      boolean flag;

 

[2]赋值                变量名 = 值;

                           age=19;

                           name="尚学堂";

                           salary=258.8;

                           sex='男';

                           flag=true;

 

[3]使用           syso(变量名)

                     System.out.println("姓名:"+name);

                     System.out.println("年龄:"+age);

     

 

合二为一

[1]声明变量并赋值     数据类型   变量名=值;

[2]使用            syso(变量名)

 

变量名的命名规则（ 必须遵守 ）

[1]可以包含字母，数字，下划线 ，$

[2]不能以数字开头

[3]不能是java关键字

 

变量名的命名规范(程序员的默认写法)

第一个单词的首字母小写，第二个单词的首字母大写  ,举例 myScore

 

使用变量时常见的错误

【1】变量尚未初始化   (变量声明，使用，但是没有赋值)

[2]变量名称重复  (改名)

 

[3]变量的名称不符合规则

 

上机练习

 

变量的分类:

  根据声明的位置分两类

【1】局部变量   :在方法中或代码块中声明的变量称为局部变量

public class TestVariable{

   //以下是程序运行的入口，称为主方法

       public static void main(String [] args){

                int age; // 局部变量age，在主方法中声明的，作用域为整个主方法

               for(int i =0;i<3;i++){   //i被声明在了for的语句结构内，i被称为局部变量,作用域只在for语句内

               

               

               }

                System.out.println(i);  //因为超出了范围(作用域)

       }

}

 

【2】成员变量 :声明在类的内部，方法外部public class TestVariable2{//类的开始

  int age; /*成员变量 ,整个类中的非static方法都可以直接使用,

  如果static的方法想使用age就需要创建对象*/

 

    //主方法

       public static void main(String [] args){

           //创建对象

                TestVariable2 t=new TestVariable2();

                //                对象名.成员变量名

               System.out.println (t.age );

   }

       

       public void show(){

               System.out.println( age );

       

       }

}//类的结束

 

成员变量与局部变量的区别：

[1]声明位置不同

[2]局部变量必须声明，赋值，才能使用,成员变量有默认值,int默认值为0,double默认值为0.0,String默认值为null,boolean默认值为false

[3]作用域同， 成员变量的作用域大，局部变量的作用域小

public class TestVariable3{

 int age;//成员变量

  public void show(){

        int age=20;//局部变量

        System.out.println(age);

  }

 

}

当局部变量与成员变量名称相同时，局部变量更具有优先级

 

常量：其值只能被赋一次，然后不允许再更改  

        在变量前加一个关键字final就可以了

   举例 :int  age=20;//这是一个变量

         final int age=20;//这是一个常量

 

public class TestFinal{

 public static void main(String [] args){

               final int age=20;  //常量

               

               System.out.println("age="+age);

                age=30;   //报错，不能为最终变量分配值

               System.out.println("age="+age);

 }

}

为了与变量进行区别，所以常量的命名规范为全部大写字母加下划线

 final int AGE =20;

标识符的命名规范

 

2.4运算符

[1]算术运算符  +，-，*，、，%，++，--

举例:

public class TestOperater{

 public static void main(String [] args){

               /*[1]算术运算符*/

               int numA=10;

               int numB=3;

               System.out.println(numA+"+"+numB+"="+( numA+numB ));

               System.out.println(numA+"-"+numB+"="+( numA-numB ));

               System.out.println(numA+"*"+numB+"="+( numA*numB ));

               System.out.println(numA+"/"+numB+"="+( numA/numB ));  // 结果为3，整除

               System.out.println(numA+"%"+numB+"="+( numA%numB ));

               /**以下两句代码，作用完全相同，因为每一句代码只执行一个操作，这个操作就是自己加1*/

                numA++; //自己本身加一，自增1

                ++numA; //自增1

               System.out.println("numA="+numA);

               

               /**以下两句代码，执行顺序不同，因为每一句代码都执行两个操作，就有先后顺序*/

                System.out.println(numA++); //执行两个操作，第一个操作是打印输出 numA的值，第二个操作是自增1

                System.out.println(++numA); //第一个操作是自增1，第二个操作是打印输出

               

               

 }

   

}

 

[2]赋值运算符  =

 

[3]关系运算符

public class TestOperater3{

 public static void main(String [] args){

 

               /*[3]关系运算符>,<,>=,<=,==,!=*/

               int numA=20,numB=10;//一次性声明两个int类型的变量，分别为numA,numB

               System.out.println( numA>numB );  //true,说明关系运算符的比较结果为boolean类型

               //System.out.println( numA=numB );   //将numB的值复制一份，赋给numA,然后再打印输出， 10

               System.out.println( numA==numB );  //false,说明numA与numB的两个变量的值不相等

               System.out.println( numA!=numB );

               

                /**==用于比较基本数据类型的"值"是否相等*/

               String a=new String("hello");

               String b=new String("hello");

               System.out.println(a==b);  //比较的是String的内存地址

               System.out.println(a.equals(b));//equals()方法用于比较String的"内容"是否相等

               

 }

   

}

[4]逻辑运算符  &&(短路与),||(短路或),!(非),&(逻辑与),|(逻辑或)

多个关系运算时，使用逻辑运算符连接

               /**短路与&&，左右两个比较结果必须均为true,结果为true,第一个比较结果为false,则第二个不计算*/

               System.out.println(8>3&&9>6);  //8>3的结果为true,9>6的结果为true,  true&&true--->true

               System.out.println(8<3&&12/0>2);//8<3的结果为false,12/0>2根本不计算

                //System.out.println(8>3&&12/0>2);8>3的结果为true,才去计算12/0报错，by zero

               

               /**逻辑&,左右两个比较结果均为true时，结果为true,无论第一个结果是否为true,都需要计算第二个*/

                //System.out.println(8<3&12/0>2); //8<3的结果为false,依然计算第二个

               

           /**短路或 ||,只要有一个为true,结果为true,如果第一个结果为true,不计算第二个*/

               System.out.println(8>3||12/0>2);  //8>3的结果为true,不计算12/0

               

               /**逻辑或| ,无论第一个是否为true,都需要计算第二个*/

               //System.out.println(8>3|12/0>2);

               

               /**逻辑与和逻辑或又被称为位运算符*/

               System.out.println(8&4);

               System.out.println(8|4);

                /**&与|即称为逻辑运算符又称为位运算符

                   看左右的操作数，如果左右为关系运算符的比较，则为逻辑运算符

                                       如果左右的操作数为数值型，则起位运算符作用

               */

 }

   

}

[5]位运算符 ( 了解即可 )

public class TestOperater5{

 public static void main(String [] args){

 

               /*[5]位运算符*/

               System.out.println( 2<<3 );  //尖角朝左为乘  相当于2*2*2*2

               System.out.println( 1<<3 ); //相当于1*2*2*2

               

               System.out.println( 12>>2 );//相当于12/2/2

               

 }

   

}

[6]条件运算符  ?:  (三目运算符)  双分支结构if...else的简写

 

public class TestOperater6{

 public static void main(String [] args){

 

               /*[6]条件运算符?:*/

         int numA=5;

         if(numA>10){

               System.out.println("numA大于10");

         }else{

               System.out.println("numA不大于10");

         }

         

         //使用三目运算符，一行搞定

         System.out.println( numA>10?"numA大于10":"numA不大于10" );

               

 }

   

}

numA>10的结果为true,输出":"之前的字符串内容

                            false,输出":"之后的字符串内容

 

[7]扩展运算符 +=,-=,*=,/=

public class TestOperater7{

 public static void main(String [] args){

 

               /*[7]扩展运算符+=,-=,*=,/=*/

        int numA=10;

        int numB=20;

        //numA=numA+numB;   //numA+numB的运算结果赋值给numA,

        numA+=numB;  //相当于numA=numA+numB

        System.out.println("numA="+numA);

               

 }

   

}

[8]连接运算符   "+"

public class TestOperater8{

 public static void main(String [] args){

 

               /*[8]连接运算符  +*/

               int numA=10,numB=20;

                 /* *第一个+的左边为String类型，右边为int类型，这个"+"起连接作用，连接

                 之后的结果为 "相加的结果为10"  

                 第二个加+的左边为  "相加的结果为10"是一个String,右边是int类型，

                 这个加号起连接作用，连接的结果为

                 相加的结果为1020

                */

               System.out.println("相加的结果为:"+numA+numB);   //1020

               

               /**

                第一个"+"的左边为int类型，右边为int类型，这个"+"的作用为加法运算, 结果为30

                 第二个"+"的左边为30，右边为String，这个"+"起连接作用,  30是加法的运算结果

               */

               System.out.println(numA+numB+"是加法的运算结果");

               System.out.println(""+numA+numB+"是加法的运算结果");

                //第一个"+"的左右只要有一个String，以后所有的+都起连接作用        

 }

   

}

 

总结：

[1]数据类型

    基本数据类型(byte,short,int,long,float,double,char,boolean)

    引用数据类型

[2]变量的使用

   声明，赋值，使用     或   声明并赋值， 使用

[3]变量的命名规则与规范

    字母，数字，下划线，$,不能以数字开头，不能是java关键字

    第一个单词首字母小写，以后每个单词首字母大写

[4]常量，使用final,

    使用大写字母加下划线

   只能赋一次值

[5]变量的分类

    成员变量与局部变量

[6]运算符

   算术运算符

   赋值运算符

   关系运算符

  逻辑运算符

  位运算符

  条件运算符

  扩展运算符

  连接运算符

 

boolean  flag=(3+4*2)/2<8&&9<10||7>8   为true

(1) (3+4*2 )/2    -->5    先算乘除，后算加减，有括号，先算括号

 

5<8&&9<10||7>8

(2) 5<8-->true  

     9<10-->true

    true&&true||7>8

    true||7>8

(3) 将true赋值给变量flag

(4) 输出flag的值

 

运算符的优先级

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