Java学习笔记（一）Java基础和类

最新推荐文章于 2024-07-18 16:29:57 发布

xmj_csdn

最新推荐文章于 2024-07-18 16:29:57 发布

阅读量736

点赞数

文章标签： java 编程语言语言编程

本文链接：https://blog.csdn.net/xmj_csdn/article/details/73368778

版权

计算机高级程序编程语言编写的程序最终都会变成能够在计算机处理器上面处理执行的机器语言，这个把人类可识的字符型数据转变为机器可识的机器指令的过程不外乎编译和解释，这两种方式的不同点在于程序运行的方式。编译过程是指一次性将整个高级语言程序进行词法分析、语法分析等操作后得到中间代码文件（可能是机器语言也可能不是，不是机器语言的话就要进一步处理），然后再将整个目标语言加载到内存执行。解释过程是指执行程序时，边解释边执行，并不生成中间文件，程序运行的控制权在解释程序。Java语言是先进行编译然后再进行解释的一门语言，它的编译过程屏蔽了底层硬件，使得它的可移植性很强，一次编程，到处执行；而它的解释过程就需要相关平台的解释器程序的支持，在Java中是通过Java虚拟机来实现的，关于虚拟机是什么后续介绍。

首先来了解一下Java语言是什么，怎么去编写，它有哪些规则，怎么让它实现我们人类想表达的意思呢？

一、基础

数据是程序中最基本的内容，一切的操作都是围绕数据进行的。Java中的数据类型分类如下图所示：

数据类型决定了数据所占用的存储空间和所允许的操作。

1.整数类型的byte、short、int、long分别表示占用1、2、4、8个字节的有符号整数，在Java中不存在无符号数。在Java程序中出现的常量整数，比如说34,26这些默认是int类型，可以用(byte)34,(short)34,26L这些方式来强制进行类型的说明，L不分大小写，也可以(long)32。

2.浮点型的float、double表示4个字节和8个字节的浮点数，同样，Java中默认常量浮点数为double类型，可以用23.3f或者(float)23.3来表示浮点型。

3.char类型代表2个字节的字母或是符号，Java中默认字符编码方式为Unicode编码。

4.boolean类型所占用的字节数依据不同的虚拟机有可能是不同的，但是在程序中它的值只能是true和false两者，它既不能用数字表示也不能用字符串表示。

5.关于引用类型稍后讲解。

那么怎么去使用这些类型呢？Java中在使用变量前先要进行如下声明：

变量声明：数据类型名字 [ = 值 ]；

常量声明：final 数据类型名字 = 值；

声明其实就是进行内存的分配，名字可以是任何字母、数字、下划线和美元符号等组成，但是不能以数字开头，也不能是Java中的关键字。数据的[]内是声明的同时可以做赋值操作。在程序运行过程中，变量有两种，固定的和变化的，不可变变量是值一旦初始化后就不可变化的数据，用来保护一些无需变化的数据,但是声明时必须进行初始化赋值，可变变量则在运行期间可以改变它的值。
那么这些数据类型之间可以进行转换吗？Java中类型之间的转换可以分为“自动类型转换”和“强制类型转换”，当以下两个条件满足时会进行自动类型的转换：
1.转换前后的数据类型要相互兼容，整形、浮点型、字符型相互兼容。
2.转换后的数据类型表示范围不小于转换前的类型。
当某运算符有两个不同类型的不同操作数会自动进行数据类型的装换，转换规则如下：

其中long类型会自动转变为浮点型的原因是它的数值表示范围大小是小于float类型的。若是在数据转换过程中容易造成数据精度的丢失，就要进行强制类型转换，强制类型转换语法如下：
（欲转换的数据类型）变量名称；
数据在声明之后，会被分配内存，若是没有赋初值，Java中都会对相应的数据类型变量赋默认值。byte、short、int、long、float、double默认为0，char默认为空字符，boolean默认为false。
数据是要参与运算的，Java中运算符有赋值运算符、算术运算符、关系运算符、逻辑运算符、位运算符，对于运算符在此不进行详细的叙述。
表达式是变量、常量、运算符、方法调用的序列，它执行指定的计算并返回某个确定的值。表达式组成了语句，之前变量的声明就是声明语句，每条语句以；结尾（除了结构控制语句）。程序是由若干条语句组成。程序的执行都是按照一定的顺序的，那么如何去控制程序的执行顺序呢？在Java中，有选择结构的if...else if...else语句和switch语句，其格式如下：

if(条件判断){
}
else if(){
}
else{
}switch（表达式){
case 常量选择1:语句体1{break;}
case 常量选择2:语句体2{break;}
default:默认语句体{break;}
default:默认语句体{break;}}








if的判断条件表达式只能是boolean类型，switch语句的判断表达式可以是byte、short、char、int、字符类型和枚举类型，jdk1.7后支持String类型,default后面的语句不需要匹配都会执行，只要先前没有break退出，break会跳出当前switch。
循环结构有while、do...while、for、foreach，他们的格式如下：

while(判断条件){
        语句1;        continue;
    ......
        语句n;
}
do{
        语句1;
    ......
        语句n;
}while(判断条件);
for(赋初始值;判断条件;增减标志量){
        语句1;        break;
    ......
        语句n;
}
for(元素类型type 元素变量var:遍历对象obj){
        引用var的语句;
}








判断条件只能是boolean值，break直接跳出循环，continue跳出这次循环，他们还可以实现带标志的跳转，如下：

for(int i = 0;i<2;i++){
        loop:
        for(int j = 0;j<2;j++){
                continue loop;
                break loop;
        }
}

顺序结构、分支结构和循环结构再加上跳转语句就可以实现任何逻辑表达。

一个程序的运行期间会产生许多的变量和常量，如果不加以区别管理会很混乱并且占用大量的存储空间。程序通过规定数据变量的作用域来进行管理，用{}划分作用域，变量只能在当前作用域调用，低级作用域可以访问高级作用域的数据，但是高级作用域不可以访问低级作用的数据，在作用域执行完成后，属于该作用域里面的变量都会清除。其实程序的运行是围绕栈进行的，所有的变量都是在栈里面生成，变量的生成和清除就是进栈和出栈的操作。作用域格式如下：

{
        int a = 9;
        {
                int b = 5;
                b = b + a;//上级的变量a是可以访问的
        }
        a = b + a;//这里会报错，因为访问不到低级作用域里的b
}

之前的各种分支循环结构也是由{}划分的作用域。另外还有一种特殊的作用域就是函数（Java 中其实是叫方法），函数的设计是为了解决代码的冗余，可以将实现相同功能的代码块命名，然后在需要用到的地方直接调用。Java中函数的定义如下：

返回值类型 方法名(参数列表){
        //方法体
        return 返回值;
} 

1.返回类型是任何有效类型，包括构造类型。如果没有返回值，则其返回类型必须是void，方法体中的返回类型必须和方法头中定义的返回类型一致，所以有返回值的函数是可以进行运算构成表达式的。

2.方法名遵循和变量名一样的命名规范。

3.参数列表是由参数类型和标识符组成的序列，每对之间用逗号隔开，参数是函数调用时接收传进来的变量值，可以没有参数，但是括号不能省略。

4.方法体放在{}中，有它的作用空间，参数和方法体中声明定义的变量都是可以使用的。

5.return语句是进行函数的返回语句，只要调用就立即结束函数的执行，若是是有返回值类型的函数则必须带有返回值。

6.方法可以嵌套递归调用，但是Java不允许嵌套定义方法。


二、类
上面介绍了基本的如何用Java这种高级语言来实现我们的逻辑，接下来就要探究Java语言的核心了———对象。用之前的那几种数据类型来实现我们想要的逻辑表达，万万是不够的，因为现实中的数据与数据之间往往存在着各种联系，若是都分散开来声明调用那后果可想而知，乱七八糟，所以就可以把这些相关的数据捆扎起来为一个整体，同时也把对这些数据的操作的函数一起绑定起来，这就形成了具有属性和方法的类，而它生成的变量叫做对象。类的声明和使用如下所示：


package com.xmj;
public class Main{
        public static void main(String[] args){
                A a = new A(2);
                a.var = 3;
                System.out.println(a.getVar());                System.out.println(A.staticVar);                System.out.println(new A(4).getVar());
        }
}
class A{	public static int staticVar;        static{                staticVar = 3;        }
        public int var;        {                var = 1;        }
        A(int var){
                this.var = var;
        }
        public int getVar(){
                return var;
        }
} 






















接下来就讲讲Java的三大特点：封装、继承、多态。



（一）封装
把属性和方法结合起来构成一个类型这就是封装，

（1）上面在Main中用关键字new实例化一个对象a，A(int var)就是A的一个构造方法，构造方法必须满足：1.名字为类名称2.没有返回值。构造方法用来对对象进行初始化的，若是不人为定义一个构造函数，系统默认生成一个空的构造函数。

（2）在上面的类A中，{}区域是一个构造代码块，它出现在类中并且在方法外面（函数内部也可以有代码块，当然作用就不一样了），它会在new一个对象时在构造方法前被调用，用来进行对象的初始化。

（3）在上述main方法内有一个new A(4).getVar()，它是一个匿名对象，也就是没有名字的对象，Java中允许这样实例化一个对象，但是没有名字也就只能使用一次。

（4）一个类可以生成很多个对象，每个对象都拥有属于自己的被封装的属性和方法，可以通过对象名称.属性（方法）的方式调用。

（5）在类A中还可以看到static关键字修饰的staticVar和static{}代码块，static关键字表示这个属性、方法、代码块是静态的，它是属于类的，是所有对象共享的全局的变量，在内存中只有一份，用来定义那些需要多个类共享的数据或方法。所以可想而知static{}修饰的静态构造代码块和static修饰的静态方法只能操作属于类的静态属性了，因为他们都是属与类的，但是既可以通过类也可以通过对象调用他们。static修饰的构造代码块在类被加载进内存时就已经被执行了（类的加载后续讲解）。

为了能够更好地去封装属性和方法，Java中定义了public、default（没有访问权限修饰符）、protected、private这几种访问控制符，它可以被用来修饰类、属性和方法。具体的访问权限规定如下：





上表中出现了包的概念，Java中关键字为package，包的引入是为了防止类的命名重名的问题。所谓的包就是指文件夹，即在不同的文件夹下面保存同名的类。包的使用方法，在类最上面加一行package的声明，通常包全部用小写字母命名。

package package名称[.package名称2.package名称3...];
使用包可以将功能相似的若干类保存在一个文件目录之中，但是这样一来就出现包之间的访问，通过import将包中的类导入，后续程序可以使用类名称，不用加上完整包名称。若是不import或者是import两个同名的类则需要加上完整的包名称指明是哪个类。包中是一些.java文件，那么这个文件中的类怎么编写呢？Java中规定Java源文件中至多有一个public类，若是有，它的名称必须和文件名称一致。

上表中还可以看到内部类这个概念，内部类就是指在一个类的内部又定义了其他类的情况。随着定义的方式和位置的不同，内部类有三种：

public class Main{
        public static void main(String[] args){
                A a = new A();                A.B b = a.new B();                b.getA();                A.D d = new A.D();                d.getA();        }
}
class A{
        int a = 5;
        static int sa = 3;
        static class D{
                public int getA(){
                        return sa;
                }
        }
        public class B{
                public int getA(){
                        return a;
                }
        }        B b = new B();
        //还有一种匿名内部类，讲解抽象和接口后补充
        public void inClass(){ 
               b.getA();
 final int c = 7; class C{ public void add(){ c = c + 1;
                               a = a + 1;
                       }         
               }
               C c = new C();
               c.add();
        }
}              






以上出现了三种内部类：
 1.在方法外部的类，方法外部的类定义时可以用和属性一样的访问控制符修饰，它可以访问外部类的任何属性和方法。A.B表示B这个内部类是在A中的，a.new B()就是说这个内部类对象所属的外部类对象是a。（这里就会传进去outer指针 outer.this.属性名来访问外部对象成员，内部类必须有一个外部对象指针，static 不需要 有外部类就行） 
2.在方法外部的static修饰的类，它的访问控制符也和属性是一样的，它只能访问外部类的静态属性和方法。用它实例化对象无需经过外部对象，只要外部类即可，因为他是属于外部类的内部类。
 3.在方法内部定义的类，它和方法里的局部成员变量一样，没有访问控制符，作用域只在外部方法内。它可以访问外部方法里的成员变量和外部类的属性和方法，当然若外部方法为static，则只能访问外部类的static成员。还有一个就是如果它需要修改外部方法的变量，那么这个变量必须是final修饰的，至于原因，后续讲解。在访问权限表中还有子类概念那就是下面将要讲解的继承。Java的这种访问权限的控制使得数据得到了更好地不同程度的保护，也一定程度地符合了实际生活中一些人事物对象的概念，只对外提供一些能够被访问到的接口。

（二）继承
继承是指以既有的类为基础，派生出新的类，通过这种方式能够快速地开发出新的类，而不需要编写相同的程序代码。父子类实现如下：

class Farther{
        String name;
        String address;
        protected int property =100;
        Farther(String name,String address){
                this.name = name;
                this.address = address;
        }
        String getName(){
                return name;
        }         
}
class Child extends Farther{
        String name;
        Farther(String name1,String name2,String address){
                super(name1,address);
                this.name = name2;
        }
        String getName(){
                return name;
        }
        String getFatherName(){
                return super.getName();
        }
        public void getProverty(){
                return proverty;
        }
}



Java中继承用extends关键字实现，子类继承父类后，就拥有了父类所有的属性和方法(static 修饰的类成员不属于继承一说，但是可以通过子类或者子类对象访问到)。在访问控制符允许的情况下，可以通过子类调用父类的任何属性和方法。但是继承也有限制条件：

1.Java不支持多重继承，即一个类只能有一个父类。

2.不能直接调用父类的私有成员。

3.子类在实例化时，一定要先调用父类的构造方法，如果父类没有显式定义构造方法，那么子类的构造方法默认调用父类的默认构造方法。若是父类显式定义了构造方法，那么就要像上面代码中一样在子类的构造方法的第一行用super()来调用父类的构造方法。

4.用final修饰的类不能被继承。

子类对象实例化的过程中，其实是先进行父类对象的实例化，然后进行子类对象的实例化。

在上面两个类中都出现的name和getName()是属性和方法的重写，即允许子类具有与父类相同的属性和方法。方法的重写需要满足：

1.参数列表和方法名称都相同

2.子类重写的方法的访问修饰符不能低于父类

3.私有方法不被重写，不会出错，但是不属于多态重写

4.static修饰的方法不被重写，不会出错，但是也不属于多态重写

5.返回类型：如果父类方法返回类型是八大基本类型则类型必须相同，若是其他引用类型则是父类返回类型或者其子类

6.子类方法异常范围小于父类或没有异常

7.final修饰的方法是不能被重写。

在对象调用重写的成员时默认是子类重写的成员，可以通过super关键字来指定调用父类的成员。但是调用父类的方法时，在父类方法中出现的重名的属性或者方法就是指父类的，并不会是子类的。子类除了继承和重写父类成员，还可以定义属于自己的成员。Java中所有的类都默认继承自Object类，关于Object类有哪些属性和方法可以查看相关文档。





在Java中有一种专门用来做父类，就是”抽象类“，还有抽象方法，用关键字abstract来表示。如下：
abstract class Father{
        String name;
        Father(String name){
                this.name = name;
        }
        public abstract String getName();
}
class Child extends Father{
        public String getName(){
                return name;
        }
}

抽象类定义规则：

（1）抽象类和抽象方法必须用abstract关键字修饰。

（2）抽象类不能直接实例化，也就是不能用关键字new去产生对象。

（3）抽象类定义时，抽象方法只需声明。

（4）含有抽象方法的类必须声明为抽象类，抽象类的子类必须覆写所有的抽象方法后才能被实例化，否则这个子类还是抽象类。

抽象类特征：

（1）抽象类中可以有构造方法，但是这些构造方法必须在子类中被调用，这点和非抽象继承是一样的。

（2）抽象类不能使用final定义。

（3）在外部抽象类不能使用static修饰，但是内部抽象类可以使用static修饰。非static修饰的内部抽象类只能在内部被继承。

（4）抽象类之中可以没有抽象方法，但即使没有也不能实例化对象。

抽象父类与一般父类的主要区别就是他自己不可以实例化对象，它的抽象方法必须被继承实现，这一标准可以用来定义类的模板，将一些需要实现的方法定义好，然后让子类去实现。

接口是Java提供的一种特殊类，它结构和抽象类非常相似，也具有数据成员和抽象方法。接口的定义和使用如下：
interface A{
        public static final String INFO = "Hello World";
        public abstract void print();
        default public void otherprint(){
                System.out.println("default other");
        }
}
class B implements A{
        public void print(){
                System.out.println("B implementation");
        }
}


                         
                         
                          
                          


                         
                         

接口使用关键字interface，接口使用原则：

（1）接口必须有子类，子类依靠implements关键字可以同时实现多个接口。

（2）接口的子类必须实现接口中所有的抽象方法。

（3）接口和一般类一样，具有数据成员和方法，但数据成员一定要赋值，且不能再更改，必须是public，static，final 修饰，可以省略。方法必须是“抽象方法”或default方法（jdk1.8支持），且只能被public，(static，default一样的性质？)，abstract，strictfp（精确浮点）修饰,可以省略。default方法是为了实现当给接口增加某个方法时，程序中那些实现这个接口的方法不会报错，他不严格检查方法实现。

（4）接口不能有构造方法，它不能实例化对象。

接口的实现解决只能单重继承的问题，它可以实现很多个接口定义的标准。


（三）多态
方法的重载就是使用方法名相同但参数不同的方法签名机制来实现静态多态。

对象的多态性就是利用方法的重写实现的，不同子类对父类相同方法的重写方式不同。下面看一段代码：

class A{
        public void print(){
        }
}
class B extends A{
        public void print(){
               System.out.println("B");
        }
        public void printB(){
               System.out.println("printB");
        }
}
class C extends A{
        public void print(){
                System.out.println("C");
        }
}
public class Main{
        public static void main(String[] args){
                A a1 = new B();
                A a2 = new C();
                a1.print();
                a2.print();
                a1.printB();//这个方法父类无法找到
                B b = (B)a1;//强制类型转换
                b.printB();
        }
}



在这里先来了解一下：向上转型和向下转型。

（1）向上转型，父类对象通过子类对象去实例化，不需要强制类型转换,但是子类对象不属于父类的部分不能被访问，比如上面的对象a1、a2赋给a，而a1.printB()会报错。

（2）向下转型，将父类对象转换为子类对象，因为子类对象能够调用的成员比父类多，如果类型不一致会发生错误，所以需要强制类型转换，比如上面的b=(B)a1;

在向上转型中，父类对象可以调用被子类对象重写的方法，那么不同的子类的实现方式不同就造成了同一类型对象的同一方法的不同表现，这就是动态多态的实现。向上转型后调用父类对象的方法时，会先调用子类中重写过的新方法。若是不想调用子类的新方法可以将此方法定义为static来隐藏。

这里补充说明一下之前讲到的匿名内部类：
abstract class A{
        public abstract void fly();
}
public class Main{
        public static void bird(A a){
                a.fly();
        }
        public static void main(String[] args){
                bird(new A(){
                        public void fly(){
                        }
                });
        }
}

上述代码中的bird方法的参数是一个A类型的变量，传入一个匿名的A类的一个实现的子类的对象，这就是匿名内部类，他只能使用一次。



三、引用类型
还记得在开始讲的数据类型中，还有引用类型没有讲，类、接口、数组都属于引用类型，引用类型是指这个变量存放的是一个地址，而地址所指向的存储空间才是这个类型实例的数据空间，生成一个实例对象时会先获得一个存放内存地址的指针，当new关键字去调用构造函数分配对象数据的存储空间后，这个指针就指向这块存储空间，所以当引用变量没有new分配内存时，它就是个值未知的一个空指针，此时对它进行操作会发生空指针异常。在方法中，若参数类型为引用类型，那么实际传进来的数据其实是一个地址，在方法里面对引用类型实例的数据的操作就是对原数据的操作，而像基本数据类型它传进来的是实参的一个副本，修改它并不会改变实参的值。

数组是用来存储多个具有相同类型的变量的类型，如下面的整型数组：

int[] a = new int[3];

a[0] = 2;

a.length;

int[] b = {2,4,5};

int[][] c = new int[2][3];

c[1][2] = 4;

int[] 就是一个整形数组类型，数组的实例化也是用new 或者直接赋值一个数组常量。通过数组下标a[0]来操作数组，也可以通过a.length来访问数组对象的成员属性。看起来数组类型和前面的类很像，那是不是定义了int[]这样一个类呢？其实数组类型是Java中的一个内置类型，它也继承自Object类，但是对它的编译运行操作是独立于类的，Java有专门的命令来实现数组的操作，数组里面数据的类型可以是基本类型或者引用类型。另外还支持多维数组，即数组中存储的类型是数组类型，就用多个[]来表示，那么二维数组a[2][3]就是这个第一维数组中的下标为2存储的数组中的下标为3的整形数的访问。



以上就是我个人对于Java基础的一个总结，希望指出错误与不足之处。