java的基础用法和常见错误

package a;

public class test1 {
    public static void main(String args[ ]){


        int [] arr[];
        int[] a = {1, 2};
        int[] a1 = new int[]{1, 2};
        int a3[] = {1, 2};
        int a2 = {1, 2};//前面要有类型

        int[][] b = {{1, 2}, {3, 4}};
        int d[][] = {{1,2 ,3, 4}, {32, 4, 3, 2}};
        int e[][] = new int [2][3];
        int [][] f = new int [4][5];
        int[][] f1 = new int [][];//告诉我们要声明大小
        int[][] m = new int[4][];

        int h = new int [][5];//这个是错误的
        int i = new int [4][7];//前面一定要声明变量的类型， 二维数组激就是二维数组， 后面要声明大小

        int x[][]=new int[][4];
        int q[][]=new int[3][];//定义多少行是必须的
    }
}

一个类可以有多个构造器，多个构造器用的是方法重载，所以方法名要相同，不同的是参数列表（参数个数、参数类型和参数的顺序），当自己没有定义构造器时，系统会自动地添加一个默认构造器，子类可以调用父类的构造器。

由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。

B是说子类构造方法， 不是说调用父类的构造方法；

继承的特点：

package a;

public class Demo {
   public static void main(String[] args) {
    new B();
   }
}
class A {
       int i = 7;
       public A() {
        System.out.println("i from A is " + i);
       }
       public void setI(int i) {
        this.i = 2 * i;
        System.out.println("i from C is "+ i);

       }
}
class B extends A{
    public B() {
      setI(20);
      System.out.println("i from B is " + i);
      System.out.println("--------------------");
      setI(i);
    }
    @Override
    public void setI(int i) {
     this.i = 3 * i;
     System.out.println("i from D is "+ i);
     System.out.println("i from E id " + this.i);
    }
}

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

private的用法
一 是方法的private

package a;
public class Demo {
    public static void main(String[] args) {
        new Person().printPerson();
        new Student().printPerson();
    }
}
class Student extends Person {
     private String getInfo() {
        return "Student";
    }
}
class Person {
   private String getInfo() {
        return "Person";
    }
    public void printPerson() {
        System.out.print(getInfo()+" ");
    }
}

private同时去掉（只能同时去， 要不然会报错）：

二是变量的private

package a;
class Father{
    private String name="tzj";
    int age=0;
}
public class Child extends Father{
    public String grade;
    public static void main(String[] args){
        Child p = new Child();
//        System.out.println(p.name);  这个会报错的
        System.out.println(p.age);
    }
}

如果子类的构造方法中没有调用父类构造方法的语句,则默认调用父类不带参数的构造方法。

类可以使用其他包中的public类

---

public class Pass{
    public static void main(String args[ ]){
        String a = new String("A");
        String b = new String("B");
        mb_operate(a,b);

        System.out.println("############"+a);
        System.out.println("############"+b);
        System.out.println(a + "." + b);
    }

    static void mb_operate(String x,String y){
        x.concat(y);
        System.out.println("------"+x.concat(y));
        System.out.println("-----"+x);
        y=x;
        System.out.println("-----"+y);
    }
}

这个可以和那个城市对比一下；形参不能改变实际参数；

---

创建对象时候，父类在前面

---

package a;

public class Test {
    public Test(){
        System.out.println("构造方法1被调用了");
    }
    public Test(int x){
        this();
        System.out.println("构造方法2被调用了");
    }
    public Test(boolean b){
        this(1);
        System.out.println("构造方法3被调用了");
    }
    public static void main(String[] args) {
        Test test = new Test(true);
    }
}

传入的这个参数， 会识别到对应的参数名字中；

---

. 实参和与其对应的形参各占用独立的存储单元

---

子类和父类可以不在同一个包中；

---

如果类是一个静态类，则可以直接使用类名.属性或者类名.方法的方式进行调用，如果类是非静态类，则需要通过new 来实例化一个类的对象，通过这个类的对象来调用方法和属性。

---

final类不能派生子类,final方法不能被覆盖。

---

)java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。

---

---

split

public class Test {
    public static void main(String[] args) {
        String[] tokens = "Welcome to Java".split("o");
        for (int i = 0; i < tokens.length; i++) {
            System.out.print(tokens[i] + " ");
        }
    }
}

---

java中什么是源文件：

---

---

---

48个关键字：
abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

---

ava.awt是一个软件包，包含用于创建用户界面和绘制图形图像的所有分类。在AWT术语中，诸如按钮或滚动条之类的用户界面对象称为组件。Component类是所有 AWT 组件的根。有关所有 AWT 组件的公共属性详细描述，请参见 Component。

---

java.lang包是java语言的核心，它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。
Thread类位于java.lang

---

java.util
包含集合框架、遗留的 collections 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式、日期时间工具等各类常用工具包

---

java.io

Java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。

---

线程调用sleep()方法后,该线程 阻塞状态

---

---

Java语言中允许一个类实现多个接口
Java语言中不允许一个类继承多个类
Java语言中允许一个类同时继承一个类并实现一个接口
Java语言中允许一个接口继承一个接口

---

---

---

线程的run()方法运行结束或被未catch的InterruptedException等异常终结,那么该线程进入死亡状态

线程进入死亡状态,但是该线程对象仍然是一个Thread对象,在没有被垃圾回收器回收之前仍可以像引用其它对象一样引用它

---

---

抽象类中必须有抽象方法，同时也可以有非抽象方法，既可以有方法的具体实现，继承抽象父类的子类中，如果子类没有实现抽象父类中的抽象方法，那么这个子类也必须声明为抽象的，即只要类中有抽象的方法那么这个类就一定是抽象类，但是抽象类中的方法不一定都是抽象方法，只是至少有一个是抽象方法即可

---

重载和重写的区别
A、重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。（但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。） B、重写规则之二：参数列表必须与被重写方法的相同。重写有个孪生的弟弟叫重载，也就是后面要出场的。如果子类方法的参数与父类对应的方法不同，那么就是你认错人了，那是重载，不是重写。 C、重写规则之三：返回类型必须与被重写方法的返回类型相同。 D、重写规则之四：重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。 E、重写规则之五：不能重写被标识为final的方法。 F、重写规则之六：如果一个方法不能被继承，则不能重写它。
注意看最后一条，不能被继承，就不能被重写。（来自百度）

---

在实现接口的时候,不一定要实现所有方法。

---

Set接口是从Collection接口继承的。

---

---

next()方法读取到空白符就结束l；

nextLine()读取到回车结束也就是“\r”；

package a;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner a  = new Scanner(System.in);
        System.out.println(a.next());
        Scanner b  = new Scanner(System.in);
        System.out.println(b.nextLine());
        }
    }