JavaSE入门

 

IDEA 基础使用​​​​​​：

     3.  导入模块的方法：a.关联导入；b.新建一个模块，复制一个代码文件然后粘贴在新建模块上

 

IDEA Common Speedkey：

 注：sout的使用有一快捷方法 

       输入“Hello World".sout会直接打出System.out.println("Hello World");

 

常用DOS命令：

操作	说明
盘符名称	盘符切换。 E：回车，表示切换到E盘
dir	查看当前路径下的内容
cd 目录	进入单级目录。
cd ..	回退到上一级目录
cd 目录1\目录2\..	进入多级目录
cd\	回退到盘符目录。
cls	清屏
exit	退出命令提示符窗口

配置环境变量作用是: 让你不用在一大堆目录里找，可以让你在任何地方使用它

HelloWorld案例的编译和运行

打开命令提示符窗口,进入到HelloWorld,java所在的目录,输入指令编译和运行.

编译:javac 文件名.java

例: javac HelloWorld.java

运行: java 类名(即文件名)

例: java HelloWorld

注:运行程序报错为非法字符的,即为中英文输入法问题

在用命令提示符窗口时的小技巧: 1.箭头上下可以切换到刚才输入的指令

 2.在输入文件名时,输入一个开头字母后按" tab "键就会出现完整的文件名字

以下为基本框架的comments.

/* Java程序中最基本的组成单位是类
    类的定义格式
        public class 类名{    
        }
     以下是我定义的HelloWorld类  */
public class HelloWorld{
         /*
            这是main方法
            main方法是程序的入口方法,代码的执行是从main方法开始的
         */
        public static void main(String[] args){
         //这是输出语句,""里面的内容是可以改变的
        System.out.println("HelloWorld");
        }

 

一. 输出常量                注: 常量null是不可以直接输出的

public class ConstantDemo{
    public static void main(String[] args){
    //字符串常量
    System.out.println("HelloWorld");
    
    //整数常量
    System.out.println(666);
    
    //小数常量
    System.out.println(3.14);

    //字符常量
    System.out.println('A');
    System.out.println('叶');

    //布尔常量
    System.out.println(true);
    System.out.println(false);

计算机存储单元:

1B(字节)=8 bit        1KB=1024B        1MB=1024KB        1GB=1024MB        1TB=1024GB

 

 二. 类型转换

1.自动类型转换: 把一个表示数据范围小的数值或变量赋值给另一个表示数据范围大的变量

注:1.表达式中最终结果类型由表达式中的最高类型决定

     2.在表达式中,byte,short,char是自动直接转化成int类型参与运算的  

byte a = 20;
byte b = 10;
byte c = a + b; //报错,a和b在此表达式中被自动转化为int类型
int c = a + b; //需要把byte类型改成int类型

 

2.强制类型转换:把一个表示数据范围大的数值或变量赋值直接赋给另一个表示数据范围小的变量是会报错的,需要用强制类型转化!

格式: 目标数据类型 变量名= (目标数据类型)值或者变量

eg: int k = (int)88.88

注:不建议用强制类型转换,可能会使部分数据丢失 

\\ 对于只有整数相除的只能得到整数,要想得到小数,必须要有浮点数的参与

 注！！！

long i = 1000000000000000；//报错！
//原因是随便写一个整数字面量默认是int类型，而该整数值超过了int类型的范围，
若要用long的类型，需要在该整数值后加l或L
long i = 1000000000000000L；
    
float j = 98.3；//报错！
//Ditto！随便写一个小数字面量默认是double类型，若要用float类型则要在该小数后加f或F
float j = 98.3F; 

 

算术运算符"+"

当"+"操作中出现了字符串,这个"+"是字符串连接符,而不是算术运算符,

注:computer is smart, if they can add that add,else link together.

 System.out.println("Geoffrey"+666);  //输出为:Geoffrey666
------------------------------------------------------------
 int a = 5;
 System.out.println(a+""+'a'); // 5a
 System.out.println(a+'a');  // 102
 System.out.println("ABC"+a+'a'); //ABC5a
 System.out.println(a+'a'+"ABC"); //102ABC
 //自增运算符++
int k = 3; //k: 3 4 5 4
int p = 5; //p: 5 4 3 4
   //sk: 3   +  5  -  4  + 4   - 5   +  4  +2 = 9
int sk = k++ + ++k - --p + p-- - k-- + ++p +2;

当连续使用"+"操作时,从左到右逐个执行

eg.1+99+"Geoffrey"  输出为: 100Geoffrey

\\"+="为扩展的赋值运算符,其底层隐含了强制类型转换,如:i+=20; 而 i=i+20时,如果i为short类型,会报错"从int转换到short可能会有损失",则应写成:  i= (short) (i+20);

逻辑异或"^":两个相同为false，两个不同为true

 

 

 输入数据

import java.util.Scanner;
\\导包，应写在类定义的上边
public class ScannerDemo{
    public static void main(Strings[] args)
{   
     \\创建对象，该格式只有sc为变量名可以改变，其他不可改变
     Scanner sc = new Scanner（System.in);
     \\接受数据，sc同上一样，而i为变量名可变，其他不可改变
     int i = sc.nextInt();
     \\输出数据
     System.out.println("i="+i);
    }
}    

 

switch语句: 1.表达式类型支持byte,short,char,int,枚举,String,不支持 float, double ,long

                    2.case 值不能是变量,只能是字面量.

\\春夏秋冬
import java.util.Scanner;
public class Season{
    public static void main(String[] args)
{    
    Scanner sc = new Scanner(System.in);
    int month = sc.nextInt(); //输入月份
    switch(month)
{
    case 1:
    case 2:
    case 12:System.out.println("冬季");break;
    case 3:    
    case 4:
    case 5: System.out.println("春季");break;
    case 6:
    case 7:
    case 8: System.out.println("夏季");break;
    case 9:
    case 10:
    case 11:System.out.println("秋季");break;
    default:System.out.println("您输入格式有误");
        }
    System.out.println(); //换行
    }
}

 

1.十进制转为二进制的运算：除二取余法

2.

八进制：每3位二进制作为一个单元，最小数是0，最大数是7，共8个数字，这就是八进制

二进制转为八进制的运算：如A的ASCII值为97，二进制为01100001，二进制转为八进制则是从右开始三个为一组来分（即八进制是三位来算的），各个组的二进制值转为十进制，连起来就是八进制了

十六进制：每4位二进制作为一个单元，最小数是0，最大数是15，共16个数字，依次用0~9 A B C D E F（ABCDEF分别代表10~15） 代表就是十六进制

注意：Java程序中支持书写二进制、八进制、十六进制的数据，分别需要以0B或者0b、0、0X或者0x开头，案例如下：

int i1 = 0B01100001;
System.out.println(i1); 
int i2 = 0141;
System.out.println(i2); 
int i3 = 0X61;
System.out.println(i3); 
//以上输出均为   97

 

  *   调用Random类生成一个范围内的随机数

package Random;
//猜数字游戏,调用Random类,nextInt(n)功能只能生成:0~(n-1)之间的随机数(左右闭区间)
//若是要生成:a~(n-1+a)之间的随机数,则是nextInt(n)+a,即原来0~(n-1)的范围左右加a 
import java.util.Random;
import java.util.Scanner;

public class RandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        int data = r.nextInt(10)+1;//随机数范围在1~10
        int input;
        System.out.println("你有三次机会猜数字!");
        for(int i = 0;i<3;i++) {
            System.out.println("请输入你要猜的数字:");
            if ((input = sc.nextInt()) == data) {
                System.out.println("恭喜您猜对了!");
                break;
            } else if(i==2)
                System.out.println("次数用完,兄弟你运气极差!");
            else
                System.out.println("错喽!再猜一次!");

        }
    }
}

//获取数组的长度
int[] arr = {12,24,36};
System.out.println(arr.length);
//数组的最大索引
数组名.length-1 //前提是元素个数要大于0

未知存入什么数据,用数组的静态初始化

已知存入什么数据,用数组的动态初始化
数据类型[] 数组名 = new 数据类型[长度];

eg.  int[] ages = new int[4];

Intellij Idea的快捷键之数组遍历
int[] arr = {20,30,40}
输入  arr.fori  就会出现一串东西,按enter键直接出现一下代码
for(int i = 0;i < arr.length;i++){                  }    

//猜数字升级版  
import java.util.Scanner;
import java.util.Random;
public class RandomDemo02{
	public static void main(String[] args){
	int[] data=new int[5];
	Random r = new Random();
	Scanner sc = new Scanner(System.in);
	for(int i =0;i<data.length;i++){
		data[i]= r.nextInt(20)+1; }
	OUT:
	while(true){
		    System.out.println("Please enter a number to guess:");
		    int guessnum = sc.nextInt();
	for(int i =0;i<data.length;i++)
  {
	if(guessnum==data[i])  {
		    System.out.println("You're right and the data's address is:"+i );
		    System.out.println("The five data are as follow:");
 	     for(int j =0;j<data.length;j++)
		    {   
		         System.out.print(data[j]+"  " ); }
		         break OUT;       }
		}
		
		System.out.println("Fault! Guess again!");
		}
	}
}
	

注意!!这里要跳脱整个循环,可以在while前面加个"标识名 :" , 如" OUT: ",则在下面跳脱语句时输入" break OUT; "                       !!!!!

 

冒泡排序法:

1思想:从头开始两两比较,把较大元素与较小元素比较进行交换,使每轮把最大的一个元素排到最后

2:实现步骤:定义一个外部循环控制总共需要进行几轮(数组长度-1 轮)

定义一个内部循环控制每轮以此然后比较几个位置(数组长度-i-1)// i为以下代码中的外部循环的

package SequenceTest;
import java.util.Scanner;
public class BubbleSequence {
    public static void main(String[] args) {
        int[] data = new int[5];
        Scanner sc = new Scanner(System.in);
        System.out.println( "Enter the arbitrary sequence:");
        for (int i = 0; i < data.length; i++) {
            data[i]=sc.nextInt();
        }
        System.out.println("The sequence sort from small to large:");
        for (int i = 0; i <data.length-1; i++) {    //i+1为第几轮排序
            for (int j = 0; j < data.length-i-1; j++) {
                if(data[j]>data[j+1]) {
                    int instant = data[j];
                    data[j] = data[j+1];
                    data[j+1] = instant;
                }
            }
        }
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
        }
    }

 

Java内存分配/数组内存图

方法区:字节码文件加载时进入的内存(即编译成class文件进入的区域)

栈内存:方法运行时所进入的内存变量也在这里(如main方法(即main函数,在java中叫方法)中的变量)

堆内存:new出来的东西会在这块内存中开辟空间并产生地址

 调试工具

 

方法的完整格式:

 

方法重载:同一个类中,出现多个方法名称相同(名称相同提示实现类似功能),通过形参列表不同实现功能差异化的选择,那么这些方法就是重载方法

形参列表不同指的是形参的个数,类型,顺序不同,不关心形参的名称

注: fire();  括号里的东西就是形参列表,fire为方法名称

 

跳脱控制语句

1.return:跳出并立即结束所在方法的执行

2.break:跳出并结束当前所在循环的执行

3:continue:结束当前所在循环的当次继续,进入下一次执行

 

面向对象编程概述:

面向:拿.找            对象:东西

面向对象:拿,找东西来编程

在java中,我们必须先设计类,才能获得对象

类(设计图): 是对象共同特征的描述        对象 :是真实存在的具体实例

如何定义类

public class 类名

{        1.成员变量(代表属性,一般是名词)

         2.成员方法(代表行为,一般是动词)

         3.构造器

         4.代码块

         5.内部类

}

定义类的注意事项

1.成员变量的完整定义格式是:修饰符 数据类型 变量名 = 初始化值; 一般无需初始化值,存在默认值  2.类名的首字母建议大写,且有意义,满足标识符规定,满足"驼峰模式" 如"NameTest"

3.一个java文件中可以定义多个class类,且public只能修饰一个类,而且public修饰的类名必须成为代码文件名. 

实际开发中建议一个文件定义一个class类.

对象的成员变量的默认值规则:

如何得到类的对象

类名 对象名 = new 类名();

eg.   Car c = new Car();

如何使用对象

访问属性 : 对象名 . 成员变量

访问行为 : 对象名 . 方法名(...)

两个对象内存图

 注:  1.对象放在堆内存中

        2.Car c  = new Car();c变量名中存储的是对象在堆内存中的地址

        3.成员变量(name. price)的数据放在对象里,存在于堆内存中.

垃圾回收:当堆内存中的类对象或数组对象没有被任何变量引用(指向)时,就会被判定为内存中的"垃圾",而Java存在自动垃圾回收器,会定期被清理.

 

构造器的作用:用于初始化一个类的对象,并返回对象的地址.  eg. Car c =new Car();

构造器的定义格式

        修饰符 类名(形参列表)        

                  {               

                                        ...... 

                                                                         }

构造器的分类: 1.无参数构造器(默认存在的):初始化对象时,成员变量的数据均采用默认值

                        2.有参数构造器:在初始化对象的时候,同时可以为对象进行赋值.

初始化对象的格式: 类名 变量名称 = new 构造器;

                              Car      c          =  new  Car()   ;

构造器注意事项:任何类定义出来,默认就自带了无参数构造器,写不写都有;但是如果你定义了有参数构造器,这个默认无参数构造器会消失,若要调用需要自己写无参数构造器了

this关键字

作用:出现在成员方法,构造器中代表当前对象的地址,用于访问当前对象的成员变量,成员方法

        this出现在构造器,或者方法中,哪个对象调用它们,this就代表哪个对象 ( 理解 ) 

public Watch(String name, double price){  //该方法输出出来还是对象中的初始值
        name= name;
        price = price;
    }
public Watch(String name, double price){  //this.名称  这样就可以赋值了
        this.name= name;
        this.price = price;
    }

 

面向对象的三大特征:封装,继承,多态.

封装:隐藏实现细节,暴露出合适的访问方式.(即合理隐藏,合理暴露)

封装的实现步骤:1.一般对成员变量使用private(私有)关键字修饰进行隐藏,private修饰后该成员变量就只能在当前类中访问; 2.提供public修饰公开getter,setter方法暴露其取值和赋值

封装的好处: 加强了程序代码的安全性;适当的封装可以提升开发效率,同时可以让程序更容易理解和维护

JavaBean:可以理解为实体类,其对象可以用于在程序中封装数据

标准JavaBean须满足如下需求:

1.成员变量使用private修饰

2.提供每一个成员变量对应的setXxx()/getXxx()

3.必须提供一个无参构造器

成员变量与局部变量的区别:

 

String类定义的变量可以用于存储字符串,同时String类提供了很多操作字符串的功能,我们可以直接使用

ArrayList代表的是集合类,集合是一种容器,跟数组类似,不同的是集合的大小是不固定的,其类型也可以选择不固定;而数组的类型是固定的,大小也是固定的,在个数不确定且需要进行增删数据操作的时候,数组就不能实现,而集合可以实现

String是(不可变)字符串类型,可以定义字符串变量指向字符串对象,String变量每次的修改其实都是产生并指向了新的字符串对象;原来的字符串对象都是没有改变的,所以称不可变字符串

创建字符串对象的两种方式:

方式一: 直接使用" "去定义(推荐)   

       eg. String name = "惠州学院";

方式二:通过String类的构造器去创建对象

通过""定义字符串内存原理图

 通过new构造器创建的        字符串对象

 String常见面试题

public class Test{
    public static void main(String[] args){
       String s2 = new String("abc");//这段代码实际创建了两个对象
       String s1 = "abc";//上一段代码已经在字符串常量池中创建abc了,则内容一样,地址一样,直接拿来用
       System.out.println(s1==s2); //false,s1内容为字符串产量池中的,而s2为堆内存中的内容
       String s3 = "ab";
       String s4 = s3+"c";
          //没有双引号进行运算的,结果均为堆内存中的内容
       System.out.println(s1==s4); //false
       String s5 = "a"+"b"+"c";
       System.out.println(s1==s5); //true
                            //Java存在编译优化机制,程序在编译时:"a"+"b"+"c"会直接转成"abc" 
    }
}

字符串内容的比较:

推荐使String类提供的"equals"比较:只关心内容一样即可

 若是基本类型比较的话则优先 使用" == "比较数据

 

String常用API

ArrayList是集合的一种,它支持索引.

ArrayList集合的对象获取  ( 无参构造器 )  eg.ArrayList list = new ArrayList();

ArrayList集合添加元素的方法

 泛型概述

ArrayList<某种数据 类型> : 其实就是一个泛型类,可以在编译阶段约束集合对象只能操作某种数据类型

eg.        ArrayList<String>:此集合只能操作字符串类型的元素

             ArrayList<Integer>:此集合只能操作整数类型的元素

注意:集合中只能存储引用类型,不支持基本数据类型

ArrayList集合常用方法