一些Java基础知识

数据类型

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

*注意:

(1)Java中,整型数据的长度与平台无关,而c/c++整型数据的长度是与平台相关的。

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

 

 

数据类型转换

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

 

 

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

 

                        Java流程控制

Java流程控制的语法与 C/C++ 类似,也有 if...elsewhiledo...whileforswitch...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 String name;
    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关键字修饰。类级变量在类定义后就已经存在,占用内存空间,可以通过类名来访问,不需要实例化。

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

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

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

/**
 * 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 extends A{

   
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 extends A{
   
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 implements A{
   
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.  

 

 

  


 

 

 

 

 



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值