java基础二（基础知识二）

目录

1.基本数据类型

1.1this和super

2.运算符和表达式

3.流程控制

4.常用类

4.1String类

4.2覆盖和重载

5.数组

一、基本数据类型

　　1、标识符

　　用名字去声明程序中的各种成员。命名规则：

• 以英文字母、下划线“_”、美元符号“$”、作为首字母。
• 区分英文字母的大小写。
• 命名的字符数没有限制。一般使用比较易读的名字。
• 不能使用关键字作为标识符的名称。可以包含关键字。
• java源程序是16位的Unicode标准，比8位的ASCll码表达更丰富。

　　2、关键字

　　java中一些标识符是系统声明的，具有专门的意义和用途。不允许作为一般的标识符使用。称为关键字。

　　关键字都用小写字母表示。java中有50个关键字：

• 数据类型：byte、short、int、long、float、double、char、boolean、false、true、new、null、void、instandeof
• 语句：if、else、switch、case、while、do、break、continue、catch、finally、default、for、return、super、this、throw、try
• 修饰符：public、private、protected、final、abstract、static、native、synchronize、transient、volatile
• 其他：class、extends、implements、import、interface、package、throws
• 保留未用：const、goto

　　注意：false和true是属于boolean，不能转换为其他数据类型。

　　

　　3、常量和变量

　　常量：是指在程度整个运行过程其值不变的量，在声明变量时，在前面加一个final修饰，就声明了一个常量。常量一旦初始化就不能被改变。

　　变量：则相反，在运行过程中是可以改变的，但，在使用前一定需要声明。变量有一定的生命周期和作用域。

　　4、基本数据类型

　　(1)基本数据类型：（由小到大）

　　整数类型：byte（8位数）、short（16位数）、int（32位数）、long（64位数）

　　浮点类型：单精度 float（32位数）、双精度 double（64位数）

　　字符类型：char（16位数）

　　布尔类型：boolean（8位数）

　　(2)引用类型：

　　字符串、数组、类、接口、Lambda

　　如果计算的时候超过表示的数据范围就叫溢出。超过最大值：上溢。反之，下溢。

　　浮点类型的下溢会表示为：0.0；下溢表示为正/负无穷大（+-INFINITY）。

　　

　　(3)类型之间的转换：

　　自动转换：将位数小的数据类型向位数多的类型进行转换。

　　强制转换：则反过来，位数多的向位数小的转换。

　　自动转换的顺序：byte、short、char-->int-->long-->float-->double

　　强制转换需要使用（），如：short aa = '1'; byte bb = (byte)aa;

　　5、引用数据类型

　　参数传递的问题：

　　(1)值传递：不会改变变量的值。实际上实参和形参是两个不同的东西，就像形参是实参的一个副本，所以，改变了副本，原本是不会改变的。

public class text {
        public static void main(String[] args) {
                int a =10;
                change(a);// 实参 
                System.out.println(a);
        }
        public static void change(int b){//形参
               b=20;
        }
}
//打印结果是10，因为改变的只是b，一个副本，原本a没有改变

　　(2)引用传递：可以改变对象的内容。实际上是实参和形参都指向同一块内存区域，所以，会改变对象的内容。

public class text {
        public static void main(String[] args) {
                int [] a={1,2,3};
                change(a);
                System.out.println(a[0]);
        }
        public static void change(int[] b ){
                b[0]=100;
        }
}
//打印100，因为a[0]和方法中b[0]是指向一块内存的

返回顶部

　　6、this和super的引用

　　构造函数不能被继承和覆盖，但是可以被重写。this和super是特殊的引用构造函数的关键字。

　　(1)this：解析引用变量与参数之间的模糊性；作为参数传递给另一个方法。

public class text{
    private String name = "huang";

public text(String name){
    this.name = name; //解析参数的模糊性
}

public text change(){
    text tt = new text(this); //作为参数传递给下一个
    tt.name = "can";
    return tt;
}
}

View Code

　　(2)super：获取父类中变量数据和调用父类中方法；直接调用父类的构造方法。

class text1{ //父类
    String name；
    public text1(){}
    public void ways(){
        System.out.println("我是父类");
}
}

class text2 extends text1{

    public text2(){
        super();//直接调用父类的构造函数
        //super.name; 调用父类的属性
        //super.ways(); 调用父类方法
}
}

View Code

　　7、基本类型的包装类

　　java对基本数据类型不作为对象处理。需要使用包装类才可以当作对象处理。

　　boolean->Boolean、byte->Byte、char->Character、short->Short、int->Integer、long->Long、float->Float、double->Double、void->Void、

返回顶部

二、运算符和表达式

　　运算：对各种类型的数据进行加工的过程。运算符：表示不用运算的符号。操作数：参与运算的数据。

　　表达式：由操作数和运算符组成。表达式运算之后的值的类型称为表达式的类型。

　　java中的算术运算符分为一元、二元运算符。

　　1、一元运算符：

　　+ (一元加)，- (一元减)，++ (增量)，-- (减量)；

　　注意：++i和i++的区别。

　　(1)单独使用：都是表示 i = i + 1

　　(2)结合其他表达式使用：++i是在使用前，先加上1，再去运算。i++是先运算后再加1

　　2、二元运算符：

　　+ (加)，- (减)，* (乘)，/ (除)，% (取模/求余)

　　注意：运算后表达式的类型

　　(1)如果操作数全是整型，其中只要有一个是long，则，表达式类型是long。其他的，结果都是int类型。

　　(2)如果操作数是浮点类型，只要有一个double，则结果就是double。只要是两个都是float，或者一个float，另一个是整型，结果才是float类型。

　　3、三元运算符：？：

　　操作的是判断和赋值的一个过程。格式：条件表达式 ？表达式1：表达式2。

　　4、关系运算符：

　　> ，<，>=，<=，== (等于)，!= (不等于)

　　注意：== 和 equals()的区别

　　(1)== ：是指两个变量或实例是不是指向同一个内存空间。

　　(2)equals():是指两个变量或实例指向的内存空间的值是否一致。

　　5、逻辑运算符：

　　&& (逻辑与)，|| (逻辑或)，！(逻辑非)

　　&&和||都是“短路”方式进行运算的，&&：只要左边的逻辑为false，就不会执行右边的语句，||：只要左边为true，也不会执行右边的语句

　　6、位运算符：

　　~ (按位取反)，& (按位与)，| (按位或)，^ (按位异或)，>>(按位右移)，<< (按位左移)，>>> (添零右移)

　　位运算符是相对于二进制数来进行位的计算的。

　　

　　(1) ^ (按位异或)：两个操作数之间，相应的位相同，结果为0，反之为1。

　　　01010110 ^ 00101110 --> 01111010

　　(2) >> (按位右移)：将一个数的二进制右移若干位。（右移1位相当于除2取商）

　　　a = 11001011 则：a>>2 = 00110010 

　　(3) << (按位左移)：将一个数的二进制左移若干位。（左移1位相当于乘2）

　　(4) >>> (添零右移)：和按位右移相同，但是，最高位是补零。

　　7、赋值运算符：

　　就是在其他的运算符后面添加一个=。如：+=、-=。

　　8、运算符的优先级：（由高到低）

　　

返回顶部

三、流程控制

　　1、最简单的是: if 、if...else、if...else if()...else、

　　2、多分支语句：switch...case....default....

　　注意：使用switch...case时：switch()括号里面的类型只能是byte、short、int、char类型。并且break的使用要慎重。如果case语句里面没有break;则执行完匹配的case语句后，后面的case里面的语句也一样会执行。

　　

　　3、循环语句：

　　(1) while(条件) (当型循环)：先计算括号的条件。满足后才执行循环体中的代码。

　　(2) do...while(条件) (直到型循环)：先执行一次，再判断条件，如果满足，再执行循环体代码。

　　(3) for(初始化、条件、迭代){ }：

　　4、break的应用

　　(1) 可以作为退出循环的语句。直接是使用break；

　　(2) 可以作为“标签化中断”。用法是 break 标记;

outer : for(int i = 0; i < 10; i++){
inner ：for(int j = 0; j < 10; j++){
             if(i = 9){
                break outer; //跳出最外的循环
}   
}
}

View Code

　　5、continue的应用

　　是跳过循环体中下面未执行的语句，继续下一轮的循环。

for(int i = 0; i < 10; i++){
    if(i == 5) continue;
    System.out.println(i);
 //不会打印5，因为continue跳出尚未执行的语句，执行下一轮       
}

View Code

　　6、递归的应用

　　递归，通俗来说就是自己调用自己。把问题逐渐简单化。

　　递归的程序非常简洁，但是需要占用大量的系统堆栈，内存消耗多。

//模拟一个求阶乘的例子
long ways(int n){
    if(n== 1) return 1;
    else return n * ways(n-1);
}

View Code

返回顶部

四、常用类

　　1、Object类

　　是所有类的根类。有6个方法可以被系统中任何类继承。

• toString()：返回当前对象信息的字符串
• equals(Object obj)：比较两个对象的值
• hashCode()：返回当前对象的哈希代码值
• getClass()：获取当前对象所属类信息，返回class对象
• clone()：对象克隆，返回复制的对象
• finalize()：声明回收当前对象所需释放资源

　　2、Class类

　　是一个自引用的数据类型。可以表示所有的java数据类型。最大的用途就是在程序执行期间帮助加载新的类。因为java中支持动态加载，所有的类仅当第一次引用时才需要加载到系统中。

　　主要的特性：

• 每一个加载到JVM的类都包含一个Class对象
• Class类是没有构造函数的，所有的类使用getClass()进行返回一个Class对象
• 可以将含有包路径的类名传给静态方法ClassforName()来动态装载类。或ClassLoader来装载。
• 该类的newInstance()创建了一个指定含有一个带参的构造方法的类的实例。

　　3、String类

　　java中，没有表示字符串的基本数据类型，只是双字节的Unicode字符序列。对字符串的处理用String、StringBuffer、StringBuilder来完成。该三个类都是final类，不能被其他类继承。String的字符串长度是不可变的。StringBuffer长度可变，支持多线程，速度稍慢。StringBuilder长度可变，不支持多线程，速度快。类中提供了很多方法，下面介绍几种常用的。

　　String中的：concat()拼接、replace()替换、substring()获取子串、toLowerCase()变小写等。具体看api文档

　　4、覆盖和重载

　　覆盖（重写）：子类必须和其父类的某个方法有相同的名称、返回类型和参数。如果一个方法被定义了final，是强制禁止覆盖的。如果被定义了abstract，是强制进行覆盖的。

　　重载：同一个类中有多个相同的方法名称，但是有着不同的参数类型的表现方式，体现为：参数的个数、参数的顺序、参数的类型。重载和访问的修饰符、返回值类型无关。

　　如果父类中的方法使用了private修饰，在子类中都不能进行覆盖和重载。

　　两者区别：

• 覆盖是子类和父类之间的关系，是垂直关系；重载是同一个类中方法之间的关系，是水平关系
• 覆盖只能由一对方法产生关系，重载是多个方法之间的关系
• 覆盖要求参数列表相同，重载要求参数列表不同
• 覆盖关系中，调用方法是根据对象的类型来决定；而重载关系是根据调用时的实参表与形参表来选择方法体的

　　5、抽象类

　　不能被实例化的类。并且必须被继承实现，其方法也必须要被重写。

　　抽象类中可以不包含抽象方法。但是抽象方法所在的类，一定是抽象类。

　　static、private、final方法不能被抽象，因为不能被子类覆盖。并final不能包含抽象方法。

abstract class text{ //定义抽象类

abstract void add();
//抽象方法是没有方法体的
}

View Code

　　6、接口

　　接口是与类关联紧密的一种引用类型。不能通过new进行实例化，必须要使用新的类来implements来实现接口。接口不仅是抽象类，而且包括任何实现，所以与存储空间无关。使用多个接口进行合并，就容易实现了多重继承的技术。

　　接口中的方法是没有方法体的。可以包含数据成员。但是一定是使用static和final声明的常量。

interface text{
final String name= "huang";//声明常量

public void add();//接口中的方法
}

View Code

　　7、内部类

　　也叫嵌套类。允许一个类声明放入另一个类声明中。

　　特点：

• 可以使用所在类的静态成员变量、实例成员变量、局部变量
• 可以用abstract声明抽象类，也可以用private、protected声明
• 可以作为其他类的成员，而且可以访问所在类的成员
• 除static内部类外，不能在类中声明static成员。

　　

　　声明的两种方法：

　　(1) 类中声明内部类，可以在内部多次使用

　　(2) 用new声明匿名内部类。创建一个对象

//(1)类中声明
class A{//外部类
    
    class B{//内部类
        void show() {
            System.out.println("我是内部类");
        }
    }
  
}

//(2)new声明
ActionListener al = new ActionListener(){ //匿名内部类
public void actionPerformed(ActionEvent event){

}
}

View Code

 返回顶部

五、数组

　　是存储一系列同类型的数据元素的一种数据结构。通过数组名和整型下标可访问数组中的每一个元素。如：a[i]

　　

　　数组创建的两种方法：

　　静态初始化、动态初始化

//(1)静态初始化
int[] a = {1,2,3};

int[] b = new int[]{1,2,3};

//(2)动态初始化
int[] c = new int[3];
c[0]= 1;
c[1]= 2;
c[2]=3;

View Code

　　二维数组的创建和一维的是一差不多的，int[][] a = new int[2][3];这样声明的是有两行三列的数组。

　　ArrayList：能动态自动调整数组大小。不必限定数组的大小。

　　创建方式：ArrayList　aa = new ArrayList();

　　一些基本方法：add()添加元素、clear()删除元素、clone()克隆元素、get(i)获取元素。

 返回顶部