java基础（知识二）

最新推荐文章于 2022-03-05 13:52:06 发布

永恒JAVA崽

最新推荐文章于 2022-03-05 13:52:06 发布

阅读量347

点赞数 1

分类专栏： java编程知识文章标签： java

本文链接：https://blog.csdn.net/weixin_44304524/article/details/104859425

版权

java编程知识专栏收录该内容

10 篇文章 2 订阅

订阅专栏

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

关键字
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修饰，就声明了一个常量。常量一旦初始化就不能被改变。
变量：则相反，在运行过程中是可以改变的，但，在使用前一定需要声明。变量有一定的生命周期和作用域。

基本数据类型
(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;

引用数据类型
参数传递的问题：
(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]是指向一块内存的

返回顶部

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;
}
}

(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(); 调用父类方法
}
}

基本类型的包装类
java对基本数据类型不作为对象处理。需要使用包装类才可以当作对象处理。
boolean->Boolean、byte->Byte、char->Character、short->Short、int->Integer、long->Long、float->Float、double->Double、void->Void、

注意：所有的包装类型都是不变类，必须使用equals()进行比较两个对象。但是，包装类对象为了节省内存，对于比较小的数，始终返回相同的实例。因此，如果对于较大的数值再使用==进行比较，就会为false。

返回顶部

二、运算符和表达式

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

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

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

一元运算符：
(一元加)，- (一元减)，++ (增量)，-- (减量)；

注意：++i和i++的区别。
(1)单独使用：都是表示 i = i + 1
(2)结合其他表达式使用：++i是在使用前，先加上1，再去运算。i++是先运算后再加1

二元运算符：
.+ (加)，- (减)，* (乘)，/ (除)，% (取模/求余)

注意：运算后表达式的类型
(1)如果操作数全是整型，其中只要有一个是long，则，表达式类型是long。其他的，结果都是int类型。
(2)如果操作数是浮点类型，只要有一个double，则结果就是double。只要是两个都是float，或者一个float，另一个是整型，结果才是float类型。

三元运算符：？：
操作的是判断和赋值的一个过程。格式：条件表达式？表达式1：表达式2。
关系运算符：
<,>=,<=,==(等于),!=（不等于）

注意：== 和 equals()的区别
(1)== ：是指两个变量或实例是不是指向同一个内存空间。
(2)equals():是指两个变量或实例指向的内存空间的值是否一致。

逻辑运算符
&& (逻辑与)，|| (逻辑或)，！(逻辑非)

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

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

位运算符是相对于二进制数来进行位的计算的。
(1) ^ (按位异或)：两个操作数之间，相应的位相同，结果为0，反之为1。
01010110 ^ 00101110 --> 01111010
(2) >> (按位右移)：将一个数的二进制右移若干位。（右移1位相当于除2取商）
a = 11001011 则：a>>2 = 00110010
(3) << (按位左移)：将一个数的二进制左移若干位。（左移1位相当于乘2）
(4) >>> (添零右移)：和按位右移相同，但是，最高位是补零。

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

返回顶部

三、流程控制

最简单的是: if 、if…else、if…else if()…else、
多分支语句：switch…case…default…

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

循环语句：
(1) while(条件) (当型循环)：先计算括号的条件。满足后才执行循环体中的代码。
(2) do…while(条件) (直到型循环)：先执行一次，再判断条件，如果满足，再执行循环体代码。
(3) for(初始化、条件、迭代){ }：
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; //跳出最外的循环
}   }}

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

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

递归的应用
递归，通俗来说就是自己调用自己。把问题逐渐简单化。
递归的程序非常简洁，但是需要占用大量的系统堆栈，内存消耗多。

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

返回顶部

四、常用类

注意：类构造器的执行顺序：
在实例化对象的时候执行的顺序是：先初始化构造器以外的实例字段，再到构造器方法的代码。一个构造器可以调用另外一个构造器，用this(…)进行调用

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

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

Class类

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

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

String类

      java中，没有表示字符串的基本数据类型，只是双字节的Unicode字符序列。对字符串的处理用String、StringBuffer、StringBuilder来完成。该三个类都是final类，不能被其他类继承。
      String的字符串长度是不可变的。
      StringBuffer长度可变，支持多线程，速度稍慢，可以支持链式操作，实现链式操作的关键是返回实例本身。
      StringBuilder长度可变，不支持多线程，速度快，用来高效拼接字符串。

类中提供了很多方法，下面介绍几种常用的。
String中的：concat()拼接、replace()替换、substring()获取子串、toLowerCase()变小写等。具体看api文档

覆盖和重载

(1)覆盖（重写）：子类必须和其父类的某个方法有相同的名称、返回类型和参数。如果一个方法被定义了final，是强制禁止覆盖的。如果被定义了abstract，是强制进行覆盖的。并且，@Override可以让编译器帮助检查是否进行了正确的覆写，但是@Override不是必需的。

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

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

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

抽象类
(1)不能被实例化的类。并且必须被继承实现，其方法也必须要被重写。
(2)抽象类中可以不包含抽象方法。但是抽象方法所在的类，一定是抽象类。
(3)static、private、final方法不能被抽象，因为不能被子类覆盖。并final不能包含抽象方法。

abstract class text{ //定义抽象类
abstract void add();
//抽象方法是没有方法体的
}

接口

接口是与类关联紧密的一种引用类型。不能通过new进行实例化，必须要使用新的类来implements来实现接口。接口不仅是抽象类，而且包括任何实现，所以与存储空间无关。使用多个接口进行合并，就容易实现了多重继承的技术。
接口中的方法是没有方法体的。可以包含数据成员。但是一定是使用static和final声明的常量。接口默认是public abstract修饰。

注意：Java的接口特指interface的定义，表示一个接口类型和一组方法签名，而编程接口泛指接口规范，如方法签名，数据格式，网络协议等。

interface text{
final String name= "huang";//声明常量
public void add();//接口中的方法
}

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

特点：
(1)可以使用所在类的静态成员变量、实例成员变量、局部变量
(2)可以用abstract声明抽象类，也可以用private、protected声明
(3)可以作为其他类的成员，而且可以访问所在类的成员
(4)除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){
}}

返回顶部

五、数组

是存储一系列同类型的数据元素的一种数据结构。通过数组名和整型下标可访问数组中的每一个元素。如：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;

     二维数组的创建和一维的是一差不多的，int[][] a = new int[2][3];这样声明的是有两行三列的数组。
     ArrayList：能动态自动调整数组大小。不必限定数组的大小。
     创建方式：ArrayList　aa = new ArrayList();
     一些基本方法：add()添加元素、clear()删除元素、clone()克隆元素、get(i)获取元素。

返回顶部

六、集合

集合框架定义各种集合类型的公共功能和各种集合间的数据交换实施。基于接口，所有的实现类都是可以交换的，所有的实现类都是可串行化和允许复制的。而且，集合中存储对象的引用而不是真正对象本身。可以分为两大类：Collection、Map

Collection：

是一个基本接口，定义了集合作为独立单元处理所需的主要操作。是最顶层的接口。其下面有LList、Set两个子接口。没有直接的实现类，只有抽象类、抽象方法。其方法实现需要实现该接口的类来实现。
在这里插入图片描述
2. Map：是定义键值对的基本接口类。

返回顶部

七、泛型

是创建一个用类作为参数的类，该参数用尖括号括起来。所需操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口、方法的创建中，分别被称为泛型类、泛型接口、泛型方法等。

泛型可以向上转型。像ArrayList可以向上转型为List。
但是，不过ArrayList无法向上转型为ArrayList或List。因为Number可以接受float类型。

Java语言的泛型实现方式是擦拭法（Type Erasure）。所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

如：ArrayList<类型> a = new ArrayList<类型>();

但是，普通的对象数组想要进行集合方法的排序，必须实现Comparable<类型>接口

使用规则：

泛型参数类型只能是类类型，不能是基本类型。
泛型参数可以有多个。
泛型参数可以使用extends，如<类型 extends testClass>
泛型参数可以是通配符类型。如Class<?>
泛型类不可以继承Exception异常类。可以被继承。
不可以定义泛型数组，不可以用泛型创建对象。
在静态方法中不可以使用泛型，泛型变量也不可以用static来修饰。
同一个泛型衍生出来的多个类之间没有任何关系，不可以相互赋值。
无法获取、判断带泛型的Class
不能实例化泛型类型

返回顶部

永恒JAVA崽

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java基础（知识二）

目录1.基本数据类型2.运算符和表达式3.流程控制4.常用类,覆盖和重载5.数组6.集合7.泛型一、基本数据类型标识符用名字去声明程序中的各种成员。命名规则:以英文字母、下划线“_”、美元符号“$”、作为首字母。区分英文字母的大小写。命名的字符数没有限制。一般使用比较易读的名字。不能使用关键字作为标识符的名称。可以包含关键字。java源程序是16位的Unic...
复制链接

扫一扫