一些Java基础知识

数据类型

(由于有很多是与c语言的数据类型相同，所以不做具体讲述)

*注意：

（1）Java中，整型数据的长度与平台无关，而c/c++整型数据的长度是与平台相关的。

(2)不同于c/c++，Java不支持无符号类型(unsigned).

 

 

数据类型转换

数据类型的转换，分为自动转换和强制转换。自动转换是程序在执行过程中“悄然”进行的转换，不需要用户提前声明，一般是从位数低的类型向位数高的类型转换；强制类型转换则必须在代码中声明，转换顺序不受限制。

 

 

强制类型转换：强制转换的格式是在需要转型的数据前加上“( )”，然后在括号内加入需要转化的数据类型。有的数据经过转型运算后，精度会丢失，而有的会更加精确，下面的例子可以说明这个问题。

 

                        Java流程控制

Java流程控制的语法与 C/C++类似，也有 if...else、while、do...while、for、switch...case等，这里不再具体讲述。

 

为大家分享一个例子：九乘九乘法表

 

运行结果

 

 

 

 

数    组

 

与C、C++不同，Java在定义数组时并不为数组元素分配内存，因此[ ]中无需指定数组元素的个数，即数组长度。而且对于如上定义的一个数组是不能访问它的任何元素的，我们必须要为它分配内存空间，这时要用到运算符new，其格式如下：
    arrayName=new type[arraySize];
其中，arraySize 为数组的长度，type 为数组的类型。

 

字   符   串

String stringName ="liudongqing ";

 

字符串可以通过“+”连接，基本数据类型与字符串进行“+”操作一般也会自动转换为字符串，

 

 

String字符串与数组有一个共同点，就是它们被初始化后，长度是不变的，并且内容也不变。如果要改变它的值，就会产生一个新的字符串，如下所示：

 

String str ="Hello ";

str +="World!";

 

String str = "Hello";

str += "World!";

这个赋值表达式看起来有点像简单的接龙，在str后面直接加上一个“World!”字符串，形成最后的字符串“Hello World!”。其运行原理是这样的：程序首先产生了str1字符串，并在内存中申请了一段空间。此时要追加新的字符串是不可能的，因为字符串被初始化后，长度是固定的。如果要改变它，只有放弃原来的空间，重新申请能够容纳“Hello World!”字符串的内存空间，然后将“Hello World!”字符串放到内存中

 

 

 

String的值是不可变的，每次对String的操作都会生成新的String对象，不仅效率低，而且耗费大量内存空间。

StringBuffer类和String类一样，也用来表示字符串，但是StringBuffer的内部实现方式和String不同，在进行字符串处理时，不生成新的对象，在内存使用上要优于String。

StringBuffer 默认分配16字节长度的缓冲区，当字符串超过该大小时，会自动增加缓冲区长度，而不是生成新的对象。

StringBuffer不像String，只能通过 new来创建对象，不支持简写方式，例如：

 

 

 

StringBuffer str1 = new StringBuffer(); // 分配16个字节长度的缓冲区

StringBuffer str2 = =new StringBuffer(512); // 分配512个字节长度的缓冲区

// 在缓冲区中存放了字符串，并在后面预留了16个字节长度的空缓冲区

StringBuffer str3 = newStringBuffer("www.weixueyuan.net");

Java中的类可以看作c语言中结构体的升级版，它的成员不仅可以是变量，还可以是函数。通过类定义的变量叫做“对象”。

 

C语言中的结构体

struct Student{

       // 结构体包含的变量

       char *name;

       int age;

       float score;

    };

 

 

Java中的类的实现

 public class Student{  // 通过class关键字类定义类

           // 类包含的变量

           String name;

           int age;

           float score;

 

           // 类包含的函数

           void say(){

               System.out.println( name + "的年龄是 " + age + "，成绩是 " + score );

           }

        }

 

*：c语言中通过结构体名臣就可以完成结构体变量的定义，并分配内存空间；但是在Java中，不会分配内存空间，必须通过new关键字完成内存空间的分配。

 

可以将类比喻成图纸，对象比喻成零件，图纸说明了零件的参数及其承担的责任；一张图纸可以生产出同一种类型的零件；不同图纸可以生产不同类型的零件。

 

在Java中，使用new关键字，就可以通过类来创建对象，这个过程叫做类的实例化，对象是类的一个实例。

Student stu=new Student();

 

*：类只起到说明的作用，不占用内存空间。

类所包含的变量称为“属性”，函数成为“方法”。

 

一个类可以包含以下类型变量

 

局部变量：在方法或者语句块中的变量成为局部变量。变量声明和初始化都是在方法中，方法结束后，变量会自动销毁。

 

成员变量：定义在类中，方法体之外的变量。

 

类变量：声明在类中，方法体之外，但必须声明为static类型。

 

 

构造方法

代码实现

/**
 * Created by LDQ on 2017/4/27.
 */
public class structure2 {
    public Stringname;
    public int age;
    structure2(String name,int age){

        this.name=name;
        this.age=age;
        System.out.println("构造方法系统自动调用!");

    }
    public  void get(){

        System.out.println(name+age);
    }
    public static void main(String args[]){
        structure2 ldq=new structure2("刘东清",20);
        System.out.println("我在学习Java的构造方法！");
        ldq.get();
    }
}

 

 

 

*注意：

(1)构造方法不能被显示调用

(2)构造方法没有返回值

 

 

 

谈谈访问修饰符

访问控制和继承

在子类中的访问权限不能低于父类中的访问权限。

 

 

 

 

Java变量的作用域

在Java中，变量的作用域分为四个级别：类级、对象实例级、方法级、块级。

类级变量又称全局级变量或静态变量，需要使用static关键字修饰。类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。

对象实例级变量就是成员变量，实例化后才会分配内存空间，才能访问。

方法级变量就是在方法内部定义的变量，就是局部变量。

块级变量就是定义在一个块内部的变量，变量的生存周期就是这个块，出了这个块就消失了，比如 if、for语句的块。块是指由大括号包围的代码

/** * Created by LDQ on 2017/4/27. */  public class zuoyongyu {    public static String name = "刘东清";  // 类级变量    public int i; // 对象实例级变量      // 属性块，在类初始化属性时候运行    {        int j = 2;// 块级变量    }      public void test1() {        int j = 3;  // 方法级变量        if(j == 3) {            int k = 5;  // 块级变量        }        // 这里不能访问块级变量，块级变量只能在块内部访问        System.out.println("name=" + name + ", i=" + i + ", j=" + j);          //System.out.println(k)  ；此处访问会报错    }      public static void main(String[] args) {        // 不创建对象，直接通过类名访问类级变量        System.out.println(zuoyongyu.name);          // 创建对象并访问它的方法        zuoyongyu t = new zuoyongyu();        t.test1();    }  }

 

 

继     承

一个新类从已有类获得属性和方法，这种现象叫做继承。

 

Java只支持单继承，不允许多继承。

单继承是指一个子类只有一个父类。

多继承是指一个子类可以有多个父类。

 

继承的好处：

1. 为多态创造条件

2. 代码重用

3. 形成类的一种层次体系结构

 

 

 

继承权限问题

 

子类中的所有方法内部可以访问父类中除私有成员外的所有成员。*注意：无法继承构造方法，在子类的构造方法中，可以通过super（参数列表）调用父类构造方法，且只能放在构造方法内的第一句。

通过子类对象可以访问：

1. 子类本身的所有成员

2. 父类除私有成员以外的成员

 

 

 

子类可以继承父类除私有成员外的所有成员。

 

 

方法重写

指在子类中重新定义父类中已有的方法。

 

重写方法和被重写方法有相同的返回值类型，参数列表，方法名称。

 

重写方法时，不能使用被重写方法更低的访问权限。

 

 

多   态

一个父类的引用变量既可以指向父类对象也可以指向子类对象，它可以根据当时指向的不同，调用不同时刻指向的不同，自动调用不同对象，这就是多态。

 

/**
 * Created by LDQ on 2017/4/28.
 */
class A{
    public void display(){
        System.out.println("AAA");
    }
}
class B extendsA{

    public void display(){
        System.out.println("BBB");
    }
}
public class duotai {
    public static void main(String[] args){
        A aa=new A();
        aa.display();
        aa=new B();
        aa.display();
    }
}

 

 

 

*注意：

（1）子类对象可以赋值给父类引用，但父类对象不能赋值给子类引用。

(2)  通过父类引用只能访问子类对象从父类继承过来的成员，不能访问子类特有成员。

        

静态成员属于类本身，即使不创建对象，也可以通过类本省来访问static成员。

 

静态成员分为：

1. 静态数据成员

2. 静态成员方法

调用静态成员的方法：

1. 类名.静态成员名

2. 类对象名.静态成员名

示例：通过一个static成员，统计总共创建了多少个对象

/**
 * Created by LDQ on 2017/4/28.
 */
public class tongji {
    public  String name;
    public  static int count=0;
    tongji(String name){

        this.name=name;
        count++;

    }

    public static void main(String[] args){

        tongji obj1=new tongji("张三");
        tongji obj2=new tongji("李四");
        tongji obj3=new tongji("王五");
        tongji obj4=new tongji("钱六");
        tongji obj5=new tongji("马七");
        System.out.println(count);
    }
}

 

 

 

 

在静态方法中只能直接调用同类中的静态成员，而不能直接访问类中的非静态成员。

 

静态方法只能访问静态成员，但非静态方法可以访问静态成员。

 

静态方法中不能以任何形式引用this和super关键字。

*注意：static类型的成员内存不会被自动回收，容易造成内存泄漏。

 

抽  象   类

抽象类通常用来作为一个类族最顶层的父类。

抽象类：

1. 用abstract关键字来修饰一个类时，该类则是抽象类。

2. 包含抽象方法的类必须声明为抽象类。

3. 抽象类可以不包含抽象方法。

4. 有抽象方法的一定是抽象类。

5. 不能new出抽象类对象。

抽象方法：

1.      只给出方法的方法头，不给出具体的实现。

2.      凡是没有方法体的方法必须加abstract关键字修饰为抽象方法。

 

可以将子类对象的地址赋给抽象类的引用，通过抽象类的引用调用子类从父类继承的方法，即通过抽象类实现多态。

示例：

/**
 * Created by LDQ on 2017/4/28.
 */

abstract class A{
    public abstract void f();

}
class B extendsA{
    public void f(){

        System.out.println("就是这样");
    }

}
public class chouxiang {
    public static void main(){

        A aa=null;
        aa=new B();
        aa.f();
    }
}

 

 

 

Final

Final可以修饰：

1. 整个类

2. 类中的若干属性和方法。

 

final 修饰整个类时表示该类不可被继承。

public final class A{……};

 

final 修饰类中的属性时，表示该属性必须被赋初值，且只能赋一次。

初始化的方法：

1. 定义变量的同时初始化

2. 在构造函数中初始化

    

    

*注意：类中所有的普通方法均不可修改被声明为final的成员变量的值。

 

 

修饰类中的方法时，表示该方法可被继承，但不可重写。

 

 

 

 

 

 

接口（interface）

就是抽象方法和常量值的集合。

 

接口中定义的属性必须是public static final类型的，方法必须是public abstract的。

接口中的属性不可被修改。

一个类只能实现接口，不能继承接口。但一个接口可以继承一个接口，且允许多继承。

 

如果一个类只实现了一个接口的部分方法，该类必须

声明为抽象类。

一个类在继承父类的同时可以实现一个或多个接口，但extends必须在implements之前。

不可以new一个接口对象，但可以定义一个接口引用类型的变量并将其指向实现接口的对象，从而达到多态度的目的。

/**
 * Created by LDQ on 2017/4/29.
 */
interface A{
    void f();



}
class B implementsA{
    public void f()        //此处的public 很关键
    {

        System.out.println("nihao");
    }
}
public class inter {
    public static void main(String[] args)
    {
        A obj1=new B();     //不可以new接口对象，但可以通过接口对象的引用指向实现接口的对象
        B obj=new B();
        obj.f();
        obj1.f();
    }

}

 

接口与抽象类的区别：

1. 接口中的方法不允许有方法体，但抽象类中却允许。

2. Java类不允许多继承，但接口允许多继承。

3.