01JAVASE-01Java基础语法

命令	描述
println	输出语句并换行
print	输出内容不换行

System.out.println("1234567890");
System.out.println("abcd");

System.out.print("\n1234567890\nabcd");

        int n = 10 / 4;     // 2

        double d = 10 / 4;  // 2.0
        d = 10.0 / 4;       // 2.5
        d = 10 / 4.0;       // 2.5
        d = (double) 10 / 4;// 2.5
        d = 10 / (double)4; // 2.5

        d = 10 / 4 * 4; //8.0
        d = 10 * 4 / 4; //10.0  注意 ：乘除的顺序可以调换的情况下，先写乘再写除。

        System.out.println(-6 % 4); // -2
        System.out.println(6 % -4); // 2
        System.out.println(-6 % -4);// -2

死循环

        for(;;){
            System.out.println("????");
        }

//        while (true){
//            System.out.println("????");
//        }

结束外层循环

		/*
			结束外层循环：
			1.给外层循环起名字 - lable是外层循环的名字，该名字可以随意去写。
			2.break后面写需要结束循环的名字
		*/
        lable : for(int i = 1; i <= 3; i++){

            for(int j = 1; j <= 3; j++){
                System.out.println("j==" + j);
                if(j == 2){
                    break lable;
                }
            }

            System.out.println("i===" + i);
        }

随机值

        int[] numbers = new int[5];
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = (int)(Math.random() * 100);
        }
        for (int i: numbers) {
            System.out.println(i);
        }

数组

        String[] strs0 = new String[]{"1", "2"};
        String[] strs1 = {"1", "2"};
        String[] strs2 = new String[2];
        strs2[0] = "1";
        strs2[1] = "2";

        int[] numbers = {1, 2, 3};
        String str = Arrays.toString(numbers);
        System.out.println(str);

        int[] numbers0 = new int[] {1, 2, 3};
        System.out.println(numbers.equals(numbers0));   // false
        System.out.println(numbers == numbers0);        // false
        System.out.println(Arrays.equals(numbers, numbers0)); // true

        numbers0 = new int[] {1, 2, 3, 6, 5};
        //void sort(int[] a) :排序
        Arrays.sort(numbers0);
        System.out.println(Arrays.toString(numbers0)); // [1, 2, 3, 5, 6]

        //int binarySearch(int[] a,int key) : 二分法查找 - 一定要先排序，如果找不到返回负数-1
        int index = Arrays.binarySearch(numbers0,  3);
        System.out.println(index);      // 2

        //void fill(int[] a,int val) : 将指定值填充到数组中
        Arrays.fill(numbers0, 4);
        System.out.println(Arrays.toString(numbers0)); // [4, 4, 4, 4, 4]

权限修饰符

/*
 * 四种权限修饰符 ： private 缺省的   protected public
 *
 * 本类中可以使用 : private,缺省的,protected,public
 *
 * 本包中（同一个包，不同类）： 缺省的，protected,public
 *
 * 不同包的子类：（protected，public）
 *
 * 不是同一个包(也不是子类) ：public,
 */

public class User {
    private String name;  // 只能当前文件访问
    protected String age;
    String niceName;
    public String sex;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

this关键字

/*
  	关键字 ：this
  	
  	this用来表示当前对象。
  	
  	this可以调用属性，方法，构造器。
  	
  	this调用属性：
  		在构造器和方法中我们可以直接调用属性，往往会省略"this."。但是局部变量名和属性名一样时。
  		那么必须使用"this."来区分属性和局部变量。
  		
  	this调用方法：
  		在同一个类中方法之间可以相互调用。在调用的时候可以省略 "this."。
  	
  	this调用构造器：
  		格式 ： this(形参列表)
  		作用 ：调用本类中的其它构造器
  		说明：
  			1.this(形参列表)必须在构造器的首行。
  			2.在同一个构造器中最多只能有一个this(形参列表)
  			3.如果有N个构造器那么最多只能有N-1个this(形参列表)
  			
 */

import关键字

/*
 * 关键字 (import) : 导包
		1. 在源文件中使用import显式的导入指定包下的类或接口
		2. 声明在包的声明和类的声明之间。
		3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可
		4. 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
		5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
		6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
		7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
		8. import static组合的使用：调用指定类或接口下的静态的属性或方法

 */

package 关键字

/*
 	关键字 (package) : Java为了实现对类进行统一的管理和划分所以有了包的概念。
 	
 	说明：
 		1.包名 ：包名应该全部小写 - xxxyyyzzz 
 		2.如何命名 ： 机构的类型（com.org.edu） + 机构的名称  + 项目名  + 模块名
 		3.每"."一下就是一层目录
 		4.同一个包中的类名不能相同，不同包中的类名可以相同。
 		5.package com.atguigu.java;必须声明在源文件的首行
 		6.在源文件中加上package com.atguigu.java，当我们进行编译时就能将生成的字节码文件放到对应的包中。
 */

继承性

/**
	面向对象特性之 : 继承性
	
	继承的好处 ： 1.减少了代码的冗余    2.提高了代码的扩展性   3.为多态提供了前提
	
	格式 ： A extends B
		 A : 子类，SubClass
		 B : 父类，SuperClass,超类，基类
		 
	说明：
		1.当一个子类继承一个父类后，子类就拥有了父类中的属性和方法。
		2.子类除了可以继承父类的属性和方法外还可以定义自己的属性和方法。（子类比父类强大）
		3.父类中的属性被私有化后，子类不能再直接访问父类中的该属性，但是我们仍然可以通过间接的方式（set/get）进行调用。
				所以我们还是认为子类继承到了该属性
		4.构造器不能被继承。
		5.java中的类是单继承。一个子类只能有一个父类。一个父类可以有多个子类。
		6.子父类的关系是相对的。父类分为直接父类和间接父类。子类可以获取父类（直接父类和间接父类）中的属性和方法
		7.当一个类没有显示的继承其它类时默认继承Object类。（Object类是所有类的父类）
 */

public class SuperUser extends User{
    @Override
    public String toString() {
        return "SuperUser{" +
                "age='" + age + '\'' +
                ", niceName='" + niceName + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        
        if (obj instanceof SuperUser){
            SuperUser u = (SuperUser) obj;
            return (u.age == this.age) && (u.niceName == this.niceName) && (u.sex == this.sex);
        }
        
        return false;
    }
}

super 关键字

/*
 	关键字：super
 	
 	super可以调用父类中的属性，方法，构造器
 	
 	super调用父类中的属性和方法：
 		在子类的构造器和方法中可以使用"super."调用父类中的属性和方法,我们可以省略"super."。
 		如果子类和父类中的属性名相同或者子类重写了父类中的方法，那么必须使用"super."来区分调用的是子类的还是父类的。
 	
 	super调用构造器 ：详见SuperTest2.java
 	
 	注意 : 只要是调用父类中的属性和方法全部加上"super."
 */

equals方法

/*
 	equals方法：
 	
 	一  Object中的equals方法：
 		  public boolean equals(Object obj) {
       		return (this == obj);
    	  }
    	   
         二 像String,Date等核心类库基本上都重写了equals方法，用来比较内容。
         
    
         三 自定义类如果没有重写equals方法那么调用的是Object中的equals方法用来比较内容。
                  但是我们自定义类的时候通常都会重写equals方法，用来比较内容.
    	  
    	  
   
    [面试题] == 和 equals的区别是什么？
    	== ：
    		基本数据类型，比较的是具体的内容是否相等。
    		引用数据类型，比较的是地址值是否相等。（两个变量指向的是否是同一个对象）
    	equals : 
    		如果没有重写Object中的方法比的是地址值
    	 	如果重写了equals方法那么通常比较的是内容
 */

自动装箱和自动拆箱

   /*
     * 基本数据类型 -> 包装类 : 通过包装类的构造器
     */
    @Test
    public void test2(){
        int a = 10;
        Integer integer = new Integer(a);
        Integer inte = new Integer(a);
        System.out.println(integer);

        boolean bo = true;
        Boolean boo = new Boolean(bo);
        System.out.println(boo);
    }
    /*
     * 包装类 -> 基本数据类型 : 包装类的对象.xxxValue()
     */
    @Test
    public void test3(){
        Integer integer = new Integer(30);
        int number = integer.intValue();
        System.out.println(number);

        Boolean boo = new Boolean(true);
        boolean booleanValue = boo.booleanValue();
        System.out.println(booleanValue);
    }
    /*
     * 自动装箱：将基本数据类型直接赋值给包装类
     * 自动拆箱: 将包装类的对象直接赋值给基本数据类型
     */
    @Test
    public void test4(){
        //自动装箱
        Integer number = 20;
        //自动拆箱
        int num = number;
        //调用方法
        info(20);//自动装箱
        //下面使用了 ： 1.自动装箱   2.多态
        Object obj = true; //自动装箱 ：1.true自动装箱  2.将对应的包装类的对象再赋值给obj
    }
    public void info(Object obj){
        System.out.println(obj instanceof Integer);
    }
    /*
     * 包装类，基本数据类型 -> String
     * 包装类 -> String :  通过toString方法
     * 基本数据类型 -> String : 1.字符串拼接   2.String.valueOf()
     */
    @Test
    public void test5(){
//		包装类 -> String :  通过toString方法
        Integer integer = new Integer(30);
        String str = integer.toString();
        System.out.println(str);    // 30

        //基本数据类型 -> String
        int number = 10;
        //第一种方式
        String s = number + "";
        System.out.println(s);      // 20
        //第二种方式
        String s2 = String.valueOf(number);
        System.out.println(s2);     // 10
    }
    /*
     * String -> 包装类，基本数据类型
     * String -> 包装类 : 通过包装类的构造器
     * String -> 基本数据类型 : Xxx.parseXxx() - 第一个Xxx对应的包装类 ，第二个Xxx对应的类型
     */
    @Test
    public void test6(){
        //String -> 包装类 : 通过包装类的构造器
//		String s = "100a";
//		Integer integer = new Integer(s); //NumberFormatException : 数值格式化异常
//		System.out.println(integer);

        //下面的特殊一些 并不会抛异常
        String s = "abc";
        Boolean boo = new Boolean(s);
        System.out.println(boo);  //false

        System.out.println("-------------------------------------------------");

        //String -> 基本数据类型 : Xxx.parseXxx() - 第一个Xxx对应的包装类 ，第二个Xxx对应的类型

        s = "11";
        int number = Integer.parseInt(s);
        System.out.println(number);  // 11

        s = "12.5";
        double parseDouble = Double.parseDouble(s);
        System.out.println(parseDouble); // 12.5
    }

    /*
     * 演示
     */
    @Test
    public void test(){
        String n = "50";
        String n2 = "100";
        System.out.println(Integer.parseInt(n) + Integer.parseInt(n2));


        Integer n3 = 100;
        int n4 = new Integer(100);
    }

static

/*
 *  
 *  变量安照位置分 ： 属性（成员变量） vs 局部变量
  				  属性（成员变量） ：  实例变量  vs 类变量（static修饰的属性）
  				  
  	static可以修饰：属性，方法，代码块，内部类
  	
  	static修饰属性（类变量）：
  		1.同一个类创建的多个对象，每个对象单独拥有一份实例变量，共同拥有一份类变量。
  		2.同一个类多个对象中某个对象对类变量进行修改后，其它的对象看到的是修改后的值。
  		3.类变量是随着类的加载而加载的（类加载加载一次）。实例变量是随着对象的创建而加载的。
  		4.调用类变量的方式 ： 类名.类变量名   对象名.类变量
  		
  	static修饰方法（静态方法）：
  		1.静态方法是随着类的加载而加载的。
  		2.静态方法中不能调用实例变量和非静态方法 (原因 ：因为加载时机不同。类加载的时候对象还没有呢)
  		3.非静态方法中可以调用类变量和静态方法
  		4.静态方法中不能使用"this"和"super"关键字
  		
  	static使用场景：
  		static修饰属性 ： 
  			1.多个对象需共同拥有该属性时那么使用static修饰
  			2.常量 ： public static final double PI = 3.14159265358979323846;
  		static修饰方法：
  			1.工具类中的方法都是静态方法
  			2.有时为了调用类变量方法也会定义成静态方法。
 */	

public class Person {
    String name;
    //实例变量
    int age;
    //类变量
    static String country;

    static {
        country = "china";
    }
    /*
     * 非静态方法 : 非静态方法中可以调用类变量和静态方法
     */
    public void info(){
        System.out.println("name=" + name + " age=" + age + " country:" + country);
        show();
    }

    /*
     * 静态方法:
     * 1.静态方法中不能调用实例变量和非静态方法 (原因 ：因为加载时机不同。类加载的时候对象还没有呢)
     */
    public static void show(){
        System.out.println("country:" + country);
//		System.out.println("static show " + name);
//		info();
    }
}

    public static void main(String[] args) {
        Person.show(); // country:china
        Person person = new Person();
        person.show(); // country:china

        person.info();
        // name=null age=0
        // country:china  country:china
    }

public class Computer {
    static int count = 0;

    public Computer(){
        count++;
    }

    public void show(){
        System.out.println("count=" + count);
    }
}

package cn.st;

public class Animal {
    String name;
    static int age;

    //非静态代码块 : 可以调用静态方法和类变量
    {
        System.out.println("非静态代码块1" + age);
        this.name = "123";
        show();
    }
	{
		System.out.println("非静态代码块2");
	}
	{
		System.out.println("非静态代码块3");
	}

    //静态代码块 : 不能调用实例变量和非静态方法
    static {
        System.out.println("静态代码块1");

    }
	static{
		System.out.println("静态代码块2");
	}
	static{
		System.out.println("静态代码块3");
	}

    public Animal() {
        System.out.println("animal()");
    }

    public void info() {
        System.out.println("non-static info");
    }

    /*
     * 静态方法
     */
    public static void show() {
        System.out.println("static show");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                '}';
    }
}

    public static void main(String[] args) {
        new Animal();
        new Animal().show();

//        静态代码块1 
//        静态代码块2
//        静态代码块3
        
//        非静态代码块10
//        static show
//        非静态代码块2
//        非静态代码块3
//        animal()
        
//        非静态代码块10
//        static show
//        非静态代码块2
//        非静态代码块3
//        animal()
        
//        static show
    }