JAVA基础个人总结1——（开头到数组部分）_若雪似风_新浪博客

Java 基础总结

 

a.新建一个环境变量：

   名称：classpath

   值：.jdk路径/lib/tools.jar;jdk路径/lib/dt.jar

b.编辑path环境变量

Java程序有哪些编码规范？

命名规范，严格区分大小写，大括号对齐，注意缩进，要写注释，每一行只写一条语句。

Java中的名称命名规范？

  1.字母，数字，下划线，$  2.数字不能开头 3.类名 接口名首字母大写，变量名 方法名首字母小写  4.驼峰命名法：第二个单词首字母大写 5.常量字母都大写 6.包名全小写

 

编写和运行Java程序的步骤是什么？每一步的结果是什么？在JDK中，Java语言的编译命令是什么，Java语言的执行命令是什么？

1.步骤：第一步，编写源程序，结果是生成.java文件 第二步是编译，结果是生成.class文件,第三步是解释执行，结果是可以看到当前程序的运行结果。

  Java语言的编译命令是javac.(类文件名) 执行命令是java

 

为了使计算机具备编译和解释JAVA语言的能力，首先安装(   JDK     )。JRE 即（ 运行环境），JVM即（虚拟机 ）

请说明switch语句中的表达式只能是什么数据类型的值。byte short int char

1. 数据类型

 

 a.基本数据类型： byte short long int double float boolean char

 b.引用数据类型： 数组，类，接口

 c.基本数据类型和引用数据类型区别:基本数据类型传递的是变量名所指的空间内的内容。引用数据类型传递的是地址。

    引用数据类型之间的赋值：数组中每个元素单独赋值

    for(int i=0;i

     {

       Mu[i]=nu[i];

     }

 

2.变量（常量）  

  数据类型 名

  int num;

  num=10;

  num=20;

 

  int[] nums;

  String xxx;

  Student ss;

 

 （常量）final 最终的

  final int NUM=20;

  标识符：类名 变量名 常量名

  规则：字母，数字，下划线，$组成 数字不能开头，不能与保留字int冲突

  规范：驼峰命名法 myScore  类名首字母大写 变量名首字母小写 常量名全大写

3.运算符

  a.算术+ - * / % ++ --   

  b.关系> >= < <= == 1= 

  c.逻辑&& & ||  

  d.三元运算符 

    ?:表达式 (条件)?结果1：结果2

 

    int x=5;

    int y=3;

    int max=(x>y)?x:y;

 e.赋值 = += -= *= /= %= 

 f.位运算符

 

4.Scanner扫描仪 说明这种类型的东西会干什么

  求一个四位整数 个 十 百 千 

 Scanner scan = new Scanner(System.in);

 System.out.println("请输入四位整数:");

 int num = scan.nextInt(9000);

 System.out.println(num+1000);

  1.找到路径

  2.创建对象

  3.对象让它做。。事情

 

1.选择结构 分支

 if....else

   if(boolean条件){代码块}

 多重if结构

 

 嵌套if结构

 

 switch...case..case...default

 

 方法

Public static void main(System.in){ 

   getSum(2,7)

}

Public static void getSum(int m,int n){

   System.out.println(m+n);

}

2.循环

  while(){}

  do{}while();

  for

  foreach

  break

  continue

 

3.数组

 数组是在内存里分配相同的空间

 一维数组

a. 什么是数组，为什么使用数组

b. 数组的特点

c. 数组的操作 

遍历（从第一个到最后一个经历一遍）：输出，求和，平均值

最值：最大，最小

查询元素

排序

冒泡排序:每次比较相邻的两个数，

 N个数字来排队，两两相比小靠前，外层循环N-1，内层循环N-1-i。

排序算法

a.递归算法：在方法里调用自己，要有出口，可以随时调用。

b.冒泡排序

c.比较交换法：从小到大

   1.通过比较交换

d.选择法:从大到小排序

 排序过程：在每一轮比较中不是每当a时就交换，而是同一个变量k记下其中最大的元素

 

二维数组

概念：二维数组就是一个数组里面又嵌套了一个数组。

  int[][] num = { 

                     {10,20,30};

{8,9,3};

{5,6,45};

};

  int[][] num=new int[3][3];

  Scanner scan=new Scanner(System.in);

  for (int i=0; i<3; i++){

   for (int j=0; j<3; j++){

      nums[i][j]=scan.nextInt();

        }

 }

    int sum1=0;int sum2=0;

    for (int i=0; i<3; i++){

for (int j=0; j<3; j++){

  System.out.print( nums[i][j] + "\t");

     if(i==j){

sum1+=nums[i][j];

}

     if(i+j==nums.length-1){

sum2+=nums[i][j];

}

    }

System.out.println();

}

       System.out.println("对角线的和是："+sum1);

       System.out.println("反对角线的和是："+sum2);

 

 

0-8数字，求第i个数在数组里的第几行第几列，i/3=hang  i%3=lie

   0  1  2

  3  4  5

   6  7  8

面向对象

对象：身边所有的物质，实体。

对象的特征：属性（用变量描述）。每个对象的每个属性都拥有特定值

行为（用方法描述，一个方法完成一个功能）

描述对象：

1.跟据对象抽象出类 写出框架 class Dog{ }

2.发现类的属性 选择需要的特征，

  class Dog{

     String name;

     int age;

     String kind;//品种

     int health; 

     int love;

  }

3.发现类的行为,功能 选择你关心的方法

 public void sayHi(){

    System.out.println(“*****”);

}

什么是类：具有相同属性和方法的一组对象的集合。类是模子，确定对象将会拥有的特征（属性）和行为（方法）。类是抽象的概念，仅仅是模板，比如：“人”

对象的概念：对象是一个能够看的到，摸得着的具体实体。

类是对象的类型，不同于int类型：具有方法。

类的写法：

定义一个类的步骤

  1、定义类名

  2、编写类的属性

  3、编写类的方法

类将现实世界中的概念模拟到计算机程序中

public class  类名 {

               //定义属性部分

               属性1的类型 属性1;

               属性2的类型 属性2;

                      …

               属性n的类型 属性n;

 

               //定义方法部分

               方法1;

               方法2;

                     …

               方法m;

}

 

创建和使用对象：

   类名 对象名 = new 类名();

   Dog dog1=new Dog();

  引用类的属性：对象名.属性

  dog1.name=”吃货”;

  dog1.age=2;

  引用类的方法：对象名.方法名()

  dog1.sayHi();

toString方法:

public String toString() {

return  "Hi~ 大家好，我的名字叫"+name+"，我的健康值是"+health+"，我的类型是:"+kind;}

   System.out.println(dog1);

 

 

 

深入

变量：成员变量和局部变量（方法，代码块）。

变量声明的位置决定变量作用域。

变量作用域确定可在程序中按变量名访问该变量的区域。

for(int i = 0, a = 0; i < 4; i++){

       a++;

}

System.out.println ( a );a的作用域仅在for循环中 ，局部变量。

class Dog{

     String name;

     int age;  成员变量

     String kind;//品种

     int health; 

     int love;

  }

在类里面定义的变量，是给类的对象使用的。

类里的成员变量在类里的所有地方都可以使用，在别的类里通过创建对象，. 使用。

变量的数据类型：

  1.基本数据类型

  2.javaAPI提供的引用类型

  3.自定义类的类型（引用类型）

  4.当使用引用类型时，注意初始化，及NullPointer的异常

 

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

作用域不同

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

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

 

初始值不同

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

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

 

在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量

 

两类变量同名时，局部变量具有更高的优先级

public class Dog {

       //特点 属性

String name;

int age;

String kind;// 品种

int health;

int love;

 public void sayHi(){

String name="aaa";

System.out.println("宠物的自白：");

    System.out.println("Hi~ 大家好，我的名字叫"+this.name+"，我的健康值是100，" +"我的类型是:"+kind);

 

定义类的方法：

语法：访问权限 返回类型 方法名（参数列表）{方法体}

public   返回值类型  方法名()  {

         //这里编写方法的主体

}

方法的返回值，两种情况

1.如果方法具有返回值，方法中必须使用关键字return返回该值，返回类型为该返回值的类型

2.如果方法没有返回值，返回类型为void

public class Student{

    String name = "张三";           String,返回类型要匹配

    public void getName(){

            return name;

        }

}

注意点：参数的个数可以多个，逗号隔开。方法调用时必须符合方法中参数的类型要求。

//区间查找

  public int search2(int begin,int end,String name){

         int result2=-1;

       for(int i=begin;i

       if(customers[i]!=null&&name.equals(customers[i].name)){

       result2=i;

       break;

       }

       }

       return result2;

}

        System.out.println("请输入开始查找的位置：");

        int n1=scan.nextInt();

        System.out.println("请输入结束查找的位置：");

        int n2=scan.nextInt();

        System.out.println("请输入学生姓名：");

        String name1=scan.next();

        int r1=n.search2(n1, n2, name1);

        if(r1!=-1){

         System.out.println("找到了");

        }else{

         System.out.println("没找到");

        }

 

 

构造方法：创建对象时 调用的方法

 

特点：1.不用自己写，系统会自动生成一隐式构造方法 

      2.写法：没有返回结果那一项，方法名跟类名一样

      3.构造方法可以有多个，可以带不同参数

      4.一旦自己写了构造方法，系统将不再自动生成隐式构造方法

 

没有返回值类型，与

  类名相同                     可以指定参数

 

public 构造方法名( ) { 

       //初始化代码

}

 

public Dog(){

 name = "吃货";

 love = 0;

 kind= "聪明的拉布拉多犬";

System.out.println(“执行构造方法”);

 }

 

一个类是可以有多个构造方法.

 

方法的重载：指同一个类中多个方法，方法名相同，参数不同。与返回值、访问修饰符无关 。

 

方法重载有两种：参数类型不同的重载、参数个数不同的重载。

 

判断哪些属于方法重载：

 

1）public void study(String name){} 

   public void study(int hours){}         方法重载

 

2）public void study(String name){} 

   public string study(String name){}         不是

 

3）public void study(String name){} 

   public boolean study(String name, int age){}      方法重载

 

4）public Student(String name){}

   public Student(String name, int age){}                构造函数重载