java快速入门

java基础

• JDK：开发工具包
• JRE：java运行环境
• JVM：虚拟机 ： 栈（基础数据类型，对象的引用地址）+堆（所有对象）+方法区（class和static变量）

JDK包括JRE包括JVM

一、配置环境变量

• JAVA_HOME
• CLASSPATH
• path

选择不同的jdk版本时，修改JAVA_HOME为解压的文件夹的路径

二、注释及命名规范、注解

import xxxxx  // 包名全小写
public class HelloWorld {  // 类名和接口名为 XxxYyy
    /**
     * 第一个Java程序
     * 它将输出字符串 Hello World
     */
    CHANG_LIANG = 0;  // 常量名全大写
    public static void main(String[] args) {  // 方法名和变量名 xxxYyy
        int a = 0;
        System.out.println("Hello World"); // 输出 Hello World
    }
}
// 写在作用区域的上方，也可以写自己的注解类
@Override // 限定这个方法是重写方法
@Deprecated  // 表示增方法过时了
@SuppressWarnings  // 抑制编译器的警告

三、基本数据类型&对应的包装类

• int —— Integer
• float —— Float
• double —— Double
• long —— Long
• byte —— Byte
• short —— Short
• char —— Character
• boolean —— Boolean

四、运算符

• && 短路与
• || 短路或
• & 与
• | 或
• ^ 异或
• ~ 反码
• << 左移 3 << 2 等于 3 * $2^2$
• $>>$ 右移
• (条件表达式) ? 表达式1 : 表达式2 ; // true 执行 1，false 执行 2。

五、包|类

• java.util —— 实用工具包，如定义系统特性、接口的集合框架类，日期日历
• java.lang —— 语言核心类包，如String，Math，Integer，System，Thread
• java.net —— 与网络相关的操作的类和接口
• java.io —— 多种输入输出功能的类
• java.text —— 格式化相关的类
• java.sql —— JDBC数据库编程相关的类和接口
• java.awt —— 抽象窗口工作集的类，用于构建和管理图形化界面GUI
• java.applet —— 包含applet运行所需要的一些类

六、分支&循环

if(  ){
   //如果布尔表达式 1的值为true执行代码
}else if(  ){
   //如果布尔表达式 2的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}
while( 布尔表达式 ) {
  //循环内容
}
switch(expression){
    case value :
       //语句
       break; //可选
    default : //可选
       //语句
}
for(int i = 0; i< n; i++){
    // continue, break
}
for(type element: array) // JDK 1.5 引进  针对数组
{
    System.out.println(element);
}

七、数组

// dataType[] arrayRefVar;   // 首选的方法 仅声明，里面均为null
// dataType[] arrayRefVar = new dataType[arraySize];
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
// 多维数组 length1必填，length2可以不同
// type[][] typeName = new type[typeLength1][typeLength2];  
int[][] a = new int[][]{
    (1,2),(2,3)
};
arr.length // 得到的是数组长度，多维数组默认是第一个【】的长度。

八、面向对象

JavaBean规则

• 类公有
• 有一个无参的构造器
• 属性一般私有，有对应的get、set方法

eclipse 快速生成get、set方法：右键–Source–Generate Getters and Setters

基本语法&关键字

package company.employ;  // 表示在company文件夹下的employ文件夹下
import com.Atest; // 引用别的文件夹com下的Atest类，本文件夹下的类不需要import

abstract class Aclass{ // 抽象类，用于被继承，不能实例化
    abstract method(int a);  //  抽象方法，没有方法的实现
}//  其子类必须重写全部方法


class final Test{  // final 类不能被继承
    final static double PAI = 3.14;  //  final 变量即为常量，且只能赋值一次
    int a; 
    Test(){}  // 默认构造方法
    final void method1(){}  //  final 方法不能被重写
    
}

public class Employee{ // 类的权限修饰符，只能是public和缺省。缺省时只能在包内使用
    
    /*执行顺序1、成员变量*/
    boolean b=true; // 默认是 false
    String name;  // 默认值为null，缺省访问权限，只能在同一个包内和类内部用，不可在子类中用
    private int age;  //默认值是0，private 是只能该类的方法调用，不能在外通过对象.属性的方式调用，用于数据保护，封装和隐藏，提供公共的方法对age进行操作。
    public salary;  // 可以在任何地方 对象.属性调用
    protected  depart;  // 缺省权限 + 子类可用
    public static sex = 'man';  // static使得，可以不实例化对象就能调用sex属性。类名.属性调用，并且所有对象共享一个sex内存地址。
    
    /*执行顺序2、初始化块。 可用于匿名类内部代替构造方法*/
    {  // 非静态的代码块
        System.out.print("先于构造方法");
    }
    static {  // 静态的代码块，只能使用静态属性和方法，且无论多少个new对象只执行一次。
        // 在实际开发中，静态的代码块用的比较多，用于初始化静态属性，尤其是静态类。
        System.out.print("先于构造方法");
    }
    
    /*执行顺序3、类构造,可以重载*/
    // public Employee(){}  // 默认构造
    public Employee(String name){  // Employee 类的构造器
        this.name = name;
    }
    public Employee(int age){  // Employee 类的构造器
        this("lzq");  // 等同于调用 public Employee(String name)
        this.age = age;
    }
    
    /*方法*/  
    public int empAge(int empAge){ // 设置age的值，参数传递是值传递：仅限基本数据类型
       age =  empAge;
       showAge();  // 调用别的方法
       return age；
    }
    
    public void showAge(){
        System.out.print(age);
    }
    
    public void changeA(Test t){  // 引用对象传递，原来的值会变：因为传进来的是指向堆内的一个地址，会直接修改堆内的数据。
        t.a = 9;
    }
    
    /*方法重载:参数个数或者参数数据类型、顺序不同*/
    public int add(int x, int y){...}
    public int add(double x, int y){...}
    public int add(int x, int y, int z){...}
    
    /*可变参数个数，声明在最后*/
    public void showInfo(int a, String... args){ // 无参数时可以不填东西。也可用数组来接收，但是调用时无参数时必须填null——即空数组
        for(String i : args){
            System.out.println(i);
        }
    }
}

class NeiBuClass{  // 内部类作用：解决java不能多重继承的问题
    int i;
    class A extents 其他类{  // 内部类，可以定义多个
        int i;  // this.i 调用
        public void setNeiBuClassFields(){
            NeiBuClass.this.i = 1;
        }
    }
    public void setInfo(){
        new A().setNeiBuClassFields();  //  外部使用内部要new
    }
}

/*实例化*/
new Employee().showAge();  // 匿名对象
Employee e = new Employee("lzq");
e.salary = 300;  // 赋值
age = e.empAge(4);  // 调用方法赋值并接收

继承&包装类使用&接口

如果子类和父类在同一个包下，只有private的属性，子类不能用。

如果子类和父类不在同一个包下，则缺省的属性也不能用。

可以把子类看作一个特殊的父类

接口里变量默认为 public static final

接口里方法 默认为 public abstract

接口可以多层继承

public interface A implements D{  // 接口可以继承接口，也可以用接口来接收继承了接口的类，但只能用属于接口的方法
    int ID = 1;
    void show();
}
public class TestIn1 implements A[,B,C]{  // 用逗号继承多个接口
    //  继承了接口后，应实现接口里定义了的全部方法，或者把类声明为abstract
}
public class Person{  // 父类
    int age;
    public void showInfo(){
        System.out.println(this.age);
    }
}
public class Student extends Person implements A{  //  子类，不能直接访问父类中的private的成员变量
    String school;
    
    /*父类方法重写 eclipse里 alt+/ 能快捷重写*/
    public void showInfo(){
        System.out.println(this.age);
        System.out.println(this.school);
    }
    /*super 关键字*/
    public void test(){
        super.age = 1;  // 父类的属性
        super.showInfo();  // 父类的方法
        super(); // 调用父类的无参构造,super(age)为有参构造调用
    }
    
    
}

class Test{
    public static void main(String[] args){   // 同理静态方法也可以不实例化就调用，static方法内只能访问static属性，不能使用this
        Person e = new Student(); // 向上转型，不可用子类的方法，父类的对象指向子类的实例
        e.showInfo() // 在多态的环境下（即有方法的重写），调用的是子类的方法。
    	// x instanceof A:  检验x是否为类A的对象，返回值为boolean
        
        /* 基类 Objeck：用于定义方法传入一个不确定的类。以下是Objeck类的方法，即所以类都能用的*/
        a.equals(b);  //  判断a和b是不是指向同一个对象。但对于特殊的File、String、Date及包装类来说，比较的是内容，而==比较的是指向的对象是否为同一个。因为这些类里面重写了equals方法
        a.hashCode();
        a.toString();  // 输出对象a的内存地址。可以重写
        
        Person p = new Student();   //子类到父类可以自动进行
        Student e = (Student)(new Person());   // 父类到子类强制转换
        /*String 对象的创建*/
        String s1 = "abc";  // 字面量创建，会在常量池中创建。省内存
        String s2 = "abc";   // 会在常量池中查找，发现有abc，直接返回相同的引用
        String s3 = "abc";   // 会先在常量池进行查找、添加，然后额外创建一个对象，返回对象的引用
    	
        /*包装类使用：基本数据类型和字符串之间的转换*/
        int i = 30； 
        Integer t = new Integer(i);  // 装箱
        Float f = new Float("3.4");
        int a = t.intValue();  // 拆箱
        Integer i1= 11;  // 自动装箱  JDK1.5以后的版本才有
        int i2 = i1;// 自动拆箱
        int i = Integer.parseInt("123");  // 字符串转数字
        String istr = String.valueOf(i);  //  数字转字符串
    }
}

设计思想：

• 类属性：当属性不因对象不同而改变，则设为static
• 类方法：当方法与调用者无关，设为static
• 可以对未来会重复使用到的代码抽象为工具类，工具类中设为静态方法。
• 抽象类里的方法应为稳定的方法。接口的方法是对一系列动作的抽象。

单例（Singleton）设计模式：

• 在整个软件系统中，对某个类有且仅有一个实例。

• 适用情况：new 对象 开销太大。

• 饿汉式的单例模式：一开始就有一个对象，大家都用同一个

  public class Single{
      private Single(){ // 构造方法私有化  ——  调用的人无法直接创建对象
          
      }
      private static Single single = new Single();  //定义private static 的一个本类变量
      
      public static Single getInstance(){  // 以后都通过这个方法得到Single对象
          return single;
      }
      
  }
  

• 懒汉式的单例模式：最开始，对象是null，直到有一个人调用，此后都用 同一个对象。

public class Single{  // 涉及线程安全问题，可修复
    private Single(){ // 构造方法私有化  ——  调用的人无法直接创建对象
        
    }
    private static Single single = null;  //定义private static 的一个本类变量
    
    public static Single getInstance(){  // 以后都通过这个方法得到Single对象
        if (single == null){  // 第一次调用才执行
             single = new Single();
        }
        return single;
    }
    
}

模板方法设计模式（TemplateMethod）

• 用抽象类和抽象方法：abstract

abstract class A{
    abstract public void showInfo();
    public void method1(){
        System.out.print("B");
    }
}

class B extents A{
    public void showInfo(){
        System.out.print("B");
    }
}

工厂方法（FactoryMethod）模式

• 将创建具体对象的工作延迟到子类，通过工厂隔离new对象。
• 用接口接收不同的实现类，使得开发人员修改类的实现的时候，不影响另一个实现类的开发人员的工作
• 适用：合作开发

public interface BWM{
    void showInfo();
}
public interface BWMFactory{
    BWM produceBWM();
}
class BWM3 implements BWM{
    public void showInfo(){
        
    }
}
class BWM3Factory implements BWMFactory{
    public BWM produceBWM(){
        
        return new BWM3();
    }
}

class Test{  // 另一个开发人员
    public static void main(String[] args){
        BWM b3 = new BWM3Factory().produceBWM();
        b3.showInfo();
    }
}

九、异常处理&泛型&枚举

• Error
• Exception
  • IOException
  • RuntimeException

public class ExcepTest{
   // 重写方法时，子类不能抛出比父类范围更大的异常
    public void test() throws Exception{ // 调用方需捕获处理，也可以继续抛出
        
    }
    int age;
    public void test1(age){
        if(0<age && age<150){
            this.age = age;
        }
        else{
            throw new Exception("age should be 0~150");
        }
    }
    public static void main(String args[]){
       try{
         
       }catch(FileNotFoundException  e){
          /*
          e.getMessage();  // 详细信息
          e.getCause();  // 原因
          e.toString();   //  简短描述
          e.printStackTrace();  // 回溯打印原应该在控制台输出的错误流
          */
          System.out.println(e.getMessage());
       }catch(IOException e){
          System.out.println("Exception thrown  :" + e);
       }finally{  // 可不写
          
       }
    }
}

泛型

class A<T> implements IB<T>{  // 泛型类
    private T key;
    
    public T setKey(T key){
        this.key = key;
        return T;
    }
    @Override
    public T test(T t){
    }
}
A<String> = a1 = new A<String>();

interface IB<T>{  // 泛型接口
    T test(T t);
}
class B implements IB<String>{
    String test(String t){}
    
    public <T> void test1(T s){  // 无返回值的泛型方法
        
    }
    public <T> T test2(T... strs){  // 有返回值的泛型方法
        return t;
    }
}

class C{
    public void test(List<?> list){
        //  ? 通配符
        // ? extends Person 只允许泛型为Person类及其子类
        // ? extends Comparable  只允许泛型为实现了Comparable接口的类
        // ? super Person  只允许泛型为Person类及其父类
    }
}
ArrayList<String> lits = new ArrayList<String>();
c.test(list);

枚举

enum Season { // 可以实现接口  
    SPRING("春天"), // 调用构造方法
    SUMMER("夏天"),
    AUTUMN("秋天"),
    WINTER("冬天");
    
    private final String name;
    
    private void Season(String name){
        this.name = name;
    }
    
    public void shouInfo(){
        System.out.println(this.name);
    }
}
Season spring = Season.SPRING;  // 每次执行得到的都是同一个对象
spring.showInfo();