Giskard

Java初级语法

2019-05-05

一、变量与数据类型

Java的应用领域

JavaWeb网站开发

安卓开发

JavaFX桌面APP

大数据应用及其他大型系统

Java语言平台

J2SE:桌面应用程序开发

J2ME:被安卓替代,移动端的程序开发

J2EE:服务器端程序开发

平台:指的是操作系统Win,Linux,Mac

跨平台:Java程序可以在任意操作系统运行,一次编写处处运行

原理:实现跨平台需要依赖Java的虚拟机JVM(Java Virtual Machine)

JRE:(Java Runtime Environment)即Java运行环境,包括了JVM和Java程序所需的核心库等。想要运行Java程序,只需要JRE

JDK:(Java Development Kit)即Java开发工具包,包括了JRE

利用JDK开发完成的程序,交给JRE去运行

常用DOS命令

//盘符切换
d:    //切到D盘
e:    //切到E盘
//列出当前目录
dir
//进入目录
cd Folder
//上一目录
cd ..
//回到根目录
cd \
//清屏
cls
//退出
exit

Java编译运行流程

my.java→编译器→my.class(字节码文件)→解释器→控制台显示

编译器和解释器在JDK中bin目录的的Javac.exe和Java.exe

//在bin目录下新建my.java
cd bin
javac my.java   //编译

//生成my.class
java my   //运行

为了让系统处处可以使用Javac和Java,所以要配置环境变量

基础语法

Ctrl Shift F 使格式变为规则

关键字:被Java赋予特定含义的单词,字母全部小写

常量:在程序运行过程中,其值不可被改变的量

字符串常量”Hello”,整数常量,小数常量,字符常量’a’,布尔常量,空常量null

字符串变量String,大写

String name = "James";
System.out.println("name is "+name);

布尔变量boolean,不能加减乘除

boolean result = a>b;

二、操作符与表达式

类型提升

当int型和double型混在一起时,隐式转换,把int提升为double型再运算

int a = 14;
double b = 5.0;
System.out.println("result: "+(a/b));
//结果2.8

不支持boolean到int的转换,支持double到int的显式转换

boolean a = true;
int b = (int) a;//错误!!!

逻辑操作符

a && b

此时a和b都要是boolean类型

赋值操作符

final相当于c语言中的const

final int a = 1;
a = 2;

三、语句

单步调试

在某一行前双击可以加断点,之后开始debug,此时断点变为箭头,意思是接下来要执行这一步,按F6可以向下走一步

continue语句

打印所有 1-20 内的数,当 n为4的整数倍时除外

for(int i=1;i<=20;i++)
{
    if(i%4 == 0)
    {
        continue;
    }
    System.out.println(i);
}

杂项

求1到100之间,所有能被3整除的数的立方和。

int sum=0;
for(int i=3;i<=100;i+=3)
{
    sum += i*i*i;
}

给定一个整数N ,判断它是否为质数

int N = 117;

boolean isPrime = true; // true: 是质数 false: 不是质数
int sub = 0; // 能被哪个数整除

for (int i = 2; i < N; i++)
{
    if (N % i == 0)
    {
       isPrime = false; // 判断是质数
       sub = i; // 记录这个因子
       break; // 已经得到结果, 退出循环
    }
}

if (isPrime)
{
    System.out.println("是质数");
} 
else
{
    System.out.println("不是质数,能被" + sub + "整除");
}

用星号打印出X型

for(int i=0;i<5;i++)
{
    for(int j=0;j<5;j++)
    {
        if(j==i || j==4-i)
        {
            System.out.print("*");
        }
        else
        {
            System.out.print(" ");
        }
    }
    System.out.println();
}

判断闰年(除以4可整除但除以100不可整除,或者,除以400可以整除)

if ( year % 4 == 0) // 是4的倍数
{            
    if ( year % 100 != 0) // 不是100的倍数
    {
        run_nian = true;
    }
    else if( year % 400 == 0) // 是400的倍数
    {
        run_nian = true;
    }
}

输出九九乘法表

for(int i=1;i<=9;i++)
{
    for(int j=1;j<=i;j++)
    {
        int plus = i * j;
        System.out.print(j + "x" + i + "=" + plus + " ");
    }
    System.out.println();
}

四、数组对象

格式

int[] arr = new int [30];

默认arr中都是0

数组长度为arr.length

对象的引用

int[] a = new int[4];
int[] b = a;

a指向了有个对象,b和a指向了一个相同的对象

int[] a = {1,1,1,1};
int[] b = a;
a = null;
System.out.print(b.length);

上面a=null表示a不再指向对象了,该对象还存在

int[] a = {1,1,1};
a = new int[4];

改变a的引用,此时{1,1,1}这个对象被(垃圾自动回收GC)删除

杂项

任意给定一个数组,
double[] src = { 4, 5.5, 6, 7.7 };

写代码把 src 中的内容倒序存储。倒序后,src的内容变成: 7.7 , 6 , 5.5 , 4

double[] src = {4,5.5,6,7.7};
int N = src.length;

for(int i=0;i<N/2;i++)
{
    double t =  src[i];
    src[i] = src[N-i-1];
    src[N-i-1] = t;
}

求出所有1000以内的质数,并存到数组里。

int[] result = new int[50]; // 最多存50个
int count = 0;

即,把找到的质数存到数组 result 里,count表示实际存入的个数

int[] result = new int[50]; // 最多存50个
int count = 0;

for(int i=2; i<1000; i++)
{
    // 判断 i 是否为质数
    boolean isPrime = true;
    for(int k=2; k<i; k++)
    {
        if( i % k == 0)
        {
            isPrime = false;
            break;
        }
    }

    // 如果是质数,则存到数组result里
    if( isPrime )
    {
        result[ count ] = i;
        count ++;
        if(count >= result.length)
        {
            break; // 已经存满50个,则退出查找
        }
    }
}

// 把找到的质数打印输出
for(int i=0; i<count; i++)
{
    System.out.println( result[i] );
}

五、类和类的属性

package one;

public class Student
{
    //属性
    public String id;
    public String name;
    public boolean sex;
    public String cellphone;
    //类的嵌套
    public StudentCards cards = new StudentCards();
}

这样其他类可以使用

Student s1 = new Student();

boolean不初始化时,默认的值是false

六、类的方法

就相当于C语言的成员函数

命名方式show、getSum

七、当前对象

要访问自己的属性和方法时,可以用this来访问

this可以省略

当方法内的属性名与对象的属性名重名时,想用对象的属性名,就要用this

八、访问控制与封装

public和private

不写访问控制符,默认private

Getter与Setter

在java里,类的属性一般设置为private

外部通过Getter读取该属性的值,通过Setter设置该属性的值

public int getNumber()
{
    return this.number;
}

public void setNumber(number)
{
    this.number = number;
}

自动添加Getter和Setter

右键source,generate getters and setters

封装

把实现细节封装到内部,不让用户看到

九、对象的创建与销毁

构造方法

名字与类名相同,无返回值

在创建对象的时候自动初始化

public Student(Student id,String name,boolean sex)
{
    this.id=id;
    this.name=name;
    this.sex = sex;
}

//在主类
Student s = new Student("1","haha",true);

对象的销毁

对象失去引用后,由垃圾回收机制GC自动回收

Garbage Collect

十、继承

用extends来表示两个类的继承关系

public child extends father
{

}

child自动继承father的所有的public属性与方法

重写Override

如果子类要重写父类的方法,在子类右键source,override/implement methods

完全重写和不完全重写

不完全重写(仅作补充作用)先使用super调用父类的方法,再在后面添加自己的。

super.show();    
System.out.println("xixi");

自动生成的@Override也是有用的,不要删除

构造方法的继承

构造方法不能叫做重写

在创建子类对象时,父类的构造方法会被自动调用

//执行
Child c = new Child();
Father f = new Father();
//得到
Father
Child
Father

如果父类有多个构造函数,如何指定调用哪个构造函数

public class Father
{
    public int a;
    public Father()
    {
        System.out.println("Father");
    }

    public Father(int a)
    {
        this.a = a;
        System.out.println("AnotherFather");
    }
}

public class Child extends Father
{
    public Child()
    {
        //使用super来指定
        super(123);
        System.out.println("Child");
    }
}

//执行
Child c = new Child();
Father f = new Father();
//显示
AnotherFather
Child
Father

单根继承

在java里,一个类只能继承一个父类

可以有继承链,A→B→C→D

继承链可以右键Quick Type Hierarchy看到

在java语言里,Object类是所有类的父类

即使没有指定

重写toString()方法

作用:在调试时快速显示对象的值

toString()是Object类的一个方法

由于所有类都是Object的子类

故所有类均可重写toString()类

在Student中

public String id;
public String name;
public boolean sex;
@Override
public String toString()
{
    // TODO Auto-generated method stub
    return "Test";
}

toString1

完善一下

public String toString()
{
    String s = "学号:"+id+",姓名:"+name;
    if(sex)
    {
        s = s+",男";
    }
    else
    {
        s = s+",女";
    }
    return s;
}

得到

toString2

多态

包含重载Overload,重写Override,泛型

//子类对象完全可以隐式转换为父类
Child c = new Child();
Father f = c; //Child->Father
//父类对象转换为子类要谨慎,要看实质,显示转换
Child c2 = (Child)f; //由于f实际上指向的是Child类的c,所以才可以转换,否则不可以

一个问题

Child c = new Child();
Father f = c;
f.show();

调用的是谁的show()?

由于是看对象实际的类型,f实际上指向的是Child类型的,故调用的是子类的show()

再谈所有类都是Object的子类

//这么写没有问题
Object o = new Child();

十一、包

定义

包:对class文件进行分类管理

选中包,右键show in →system explorer

类名使用点号可以表示文件夹的层次关系
层次

引用别的包的类时

import one.HelloWorld;
//引入该包所有类
import one.*;

点小箭头,Package Presentation->Hierarchical

可以把one.two这样的包按层级显示

eclispe快捷操作

修改类名,属性名,方法名

Refactor,Rename

eclipse会自动修改所有已经关联的名字

Ctrl+鼠标为查看定义

十二、静态方法

静态方法

没有访问this的属性和方法,将该方法拷贝到哪个类都行,与上下文没什么关系,就是一种工具

静态方法用static修饰,不能访问this,跟类没有关系

在别的地方调用时不必新建对象,只需要Hello.isPrime(123);即可

即 类.静态方法

java给出的静态方法

用斜体字显示

//四舍五入
Math.round(-1.1);

程序的入口

只有main方法可以作为程序的入口

用static修饰,说明该方法独立于该类,可以放到别的类下

十三、常见工具类

字符串类

中文字符和英文字符都只占一个字符

//空字符串
String s = "";

空字符串和null是两回事,空字符串是一个正常的字符串对象,null不指向任何对象

//子串
String s = "1234"
s.substring(1,3)
//即23,不包括end

用equals判断是否相等

true表示相同,false为不同

用compareTo表示大小判断

s1.compareTo(s2);

小于0为负数,等于0为相等

忽略大小写的比较为compareToIgnoreCase()

format格式化

String s = String.format("姓名:%s,年龄:%d","Tom",35);

indexOf查找子串位置

String s = "China";
int pose = s.indexOf("ina");
//返回值小于0表示没找到

endsWith和startsWith表示前缀和后缀

trim()方法可以去除字符串左右两边的空格,但中间的不能去掉

split()方法将大字符串分为多个小字符串

String s = "a,b,c";
String[] p = s.split(",");
//以逗号分隔开

包装类

每一个基本类型都对应一个包装类型

long→Long

int→Integer

boolean→Boolean

int a = 10;
Integer b = new Integer(10);

所有的类都是Object的子类,所以用Integer可能会方便些,而int不是类

//基本类型和包装类型的转换
Integer a = new Integer(10);
int b = a.intValue();
//也可以更简洁
Integer k = 123;
int m = k;

数值类型与String类型转换

//int到String
String s = String.valueOf(123);
//String到int
int a = Integer.valueOf(s);

对于包装类,只能用equals比较

Random类

Random类是JDK的自带类

import java.util.Random;

Random r = new Random();
int s = r.nextInt(1001);
//生成0到1000,即0到n-1

字符

用char表示单个字符,可表示中文字符或某个字母

String str = "hello";
char c = str.charAt(1);
//即取出e

char[] cs = str.toCharArray();
//将字符串转化为char型数组

再谈equals

equals判断a和b的内容是否相等

==判断是不是同一对象

十四、链表

容器

用来存储对象

比方说数组就是一种容器

Student[] ss = new Student[4];

数组容器缺点:

1、容量固定,无法扩展

2、插入和删除困难

另外一种容器:链表

无头链表

无头

链表的建立与遍历

public class Monkey
{
    public int id;
    public String name;
    public Monkey next; //后面的猴子

    public Monkey(int id,String name)
    {
        this.id=id;
        this.name = name;
    }
    @Override
    public String toString()
    {
        return String.format("(%s,%d)",name,id);
    }
}

Monkey m1 = new Monkey(1,"A");
Monkey m2 = new Monkey(2,"B");
Monkey m3 = new Monkey(3,"C");

Monkey node = m1;//指定头结点

m1.next = m2;
m2.next = m3;
m3.next = null;

while(node!=null)
{
    System.out.println(node);
    node = node.next;
}

链表中插入节点

1、插入到末尾

Monkey tail = m1;
while(tail.next != null)
{
    tail = tail.next;
}

Monkey m4 = new Monkey(4,"D");
tail.next = m4;

2、插入到头结点后面

Monkey head = m1;
m4.next = head.next;
head.next = m4;

3、插入到指定节点之后

Monkey node = m1;
while(node!=null)
{
    if(node.id==2)
    {
        m4.next = node.next;
        node.next = m4;
        break;
    }
    node = node.next;
}

有头链表

使用一个假节点作为链表的头部

有头

Monkey head = new Monkey(0,"Fake");

head.next = m1;
m1.next = m2;
...
m3.next = null;

//遍历
Monkey m = head.next;
while(m!=null)
{
    ...
    m = m.next;
}

//新节点挂在头结点后面
m4.next = head.next;
head.next = m4;

//删除节点
Monkey node = head;
while(node.next!=null)
{
    if(node.next.id==3)
    {
        node.next = node.next.next;
        break;
    }
    node = node.next;
}

链表与容器

严格来说,链表不是容器,而是容器的实现方法

ArrayList

ArrayList是java自带的工具类,兼具Array和List的双重特点,可以成为数组链表

ArrayList是一个容器,可以存储任何对象

提供了丰富的方法操作

add(),remove()

import java.util.ArrayList;

Student s1 = new Student(1,"A");
Student s2 = new Student(2,"B");
Student s3 = new Student(3,"C");

ArrayList container = new ArrayList();
container.add(s1);
container.add(s2);
container.add(s3);

//遍历
for(int i=0;i<container.size();i++)
{
    Student s = (Student)container.get(i);
    System.out.println(s);
}
//删除
container.remove(1);

十五、补充语法

条件表达式

int max = ( a > b ) ? a : b ;

for的遍历

普通

for(int i=0; i<arr.length; i++)
{
    String a = arr[i];
    System.out.println("姓名: " + a);
}

简写

for(String a : arr)
{
    System.out.println("姓名: " + a);
}
Tags: Java