java基础

第一个java程序

public class HelloWorld {
    /* 第一个Java程序
     * 它将输出字符串 Hello World
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 输出 Hello World
    }
}

HelloWorld是一个类，用class标识符声明类

上述程序将打印Hello World

数据类型

关键字	数据类型
byte	整数
int	整数
float	单精度浮点数
double	双精度浮点数
boolean	布尔值
char	字符
string	字符串

变量命名规则

• 使用有意义的名字： 变量名应该具有清晰的含义，能够准确地反映变量的用途。避免使用单个字符或无意义的缩写。
• 驼峰命名法（Camel Case）： 在变量名中使用驼峰命名法，即将每个单词的首字母大写，除了第一个单词外，其余单词的首字母都采用大写形式。例如：myVariableName。
• 区分大小写： Java 是大小写敏感的，因此变量名中的大小写字母被视为不同的符号。例如，myVariable 和 myvariable 是两个不同的变量。
• 不以数字开头： 变量名不能以数字开头，但可以包含数字。

循环

//基础循环
while(){}
do{}while();
for(;;;){}
//java增强for循环，用于数组
for(声明语句 : 表达式){}
		//例
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
   System.out.print( name );
   System.out.print(",");
}//遍历所有names中的元素
//控制语句
break;
continue;

条件语句

//两种情况
if(){}
else{}
//多情况
if(){}
else if(){}
else if(){}
else{}

数组

//声明数组
dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法
//创建数组（使用new）
arrayRefVar = new dataType[arraySize];

数组做参数传递

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

正则表达式

java支持正则表达式

import java.util.regex.*

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个”规则字符串”，这个”规则字符串”用来表达对字符串的一种过滤逻辑。

给定一个正则表达式和另一个字符串，我们可以达到如下的目的：

• 给定的字符串是否符合正则表达式的过滤逻辑（称作”匹配”）；
• 可以通过正则表达式，从字符串中获取我们想要的特定部分。

例

校验QQ号，要求：必须是5~15位数字，0不能开头。

没有正则表达式之前

public class regex {
    public static void main(String[] args) {
        checkQQ("0123134");
    }
    public static void checkQQ(String qq)
    {
        int len = qq.length();
        if(len>=5 && len <=15)
        {
            if(!qq.startsWith("0"))
            {
                try
                {
                    long l = Long.parseLong(qq);
                    System.out.println("qq:"+l);
                }        
                catch (NumberFormatException e)
                {
                    System.out.println("出现非法字符");
                }
            }
            else
                System.out.println("不可以0开头");
        }
        else
            System.out.println("QQ号长度错误");
        }
}

使用正则表达式之后的代码：

public class regex {
    public static void main(String[] args) {
            checkQQ2("0123134");
    }
    public static void checkQQ2(String qq) {                                                            
            String reg = "[1-9][0-9]{4,14}";                  
            System.out.println(qq.matches(reg)?"合法qq":"非法qq");                                 
    }
}

方法

方法即函数

方法重载

名称相同，但输入参数、返回类型不同的方法

重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法

如

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}
//重载
public static int max(int num1, int num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；

如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；

构造方法

在创建对象时自动调用

finalize() 方法

在销毁对象时自动调用

面向对象

Java作为一种面向对象语言。支持以下基本概念：

• 多态
• 继承
• 封装
• 抽象
• 类
• 对象
• 实例
• 方法
• 重载

类与对象

类：模板，例如人，有身高，体重，性别等属性

对象：对照类，对象就是类的具体化，一个人身高1.8m，体重70kg，性别男，这些具体化的类即为对象。

实例

public class Dog {
    String breed;
    int size;
    String colour;
    int age;
 
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    }
}

除属性外，类中也可以定义多个方法（函数）如上中run,eat

类中有一些特殊方法：

构造方法

public class Puppy{
    String name;
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

构造方法的特点是在创建一个对应类的对象时，会自动调用构造方法，构造函数常用于初始化对象参数。

puppy myPuppy =new Puppy("tommy");
    //初始设置name为tommy

java包

用于编译器快速找到类所在地址

包创建

package net.java.util;
public class Something{
   ...
}

则它的保存路径应该是 net/java/util/Something.java

导入包

import java.io.*;
    //将载入java/io下的所有类

通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 abc.com，所有的包名都以 com.abc开头

例如：有一个 com.abc.test 的包，这个包包含一个叫做 ABC.java 的源文件，那么相应的，应该有如下面的一连串子目录：

com\abc\test\ABC.java

继承

关键字extends implements

继承格式

class 父类 {
}
 
class 子类 extends 父类 {
}

继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, int myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法,输出‘dog : eat’
    super.eat();  // super 调用父类方法，输出‘animal : eat’
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

final关键字

final，翻译：最终的
即不能被继承

重写（Override）或重载（Overload）

抽象类

不能实例化对象的类，抽象类必须被继承，才能被使用。

abstract class 来定义抽象类

抽象方法

只声明，不具体实现，具体实现放在子类中

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();//抽象方法，具体代码块必须在子类中重新实现
   
   //其余代码
}

接口

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。

接口的声明语法格式如下：

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

例

/* 文件名 : Animal.java */
public interface Animal {
   public void eat();
   public void travel();
}

接口必须有实现类，实现方法如下：

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
 
   public void eat(){//实现接口中的方法
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

打赏