【java学习笔记】

前言

虽然在学校里已经学过一遍java，但总感觉没学到什么东西。趁暑假有时间，再学一遍。学完后发现，有些东西不止得学一遍，每学一遍就有新的收获！
第一个程序！

public class practice {//practice是公共类名也是Java文件的名字。
    public static void main(String[] args){
        System.out.println("Helo World!");
    }
}

java关键字类型

private 私有的
protected 受保护的
public 公共的
default 默认
abstract 声明抽象
class 类
extends 扩充,继承
final 不可改变
implements 实现（接口）
interface 接口
native 本地
new 创建
static 静态

变量类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte 字节型 8位
int 整型 32位
long 长整型 64位
short 短整型 16位
double 双精度浮点 64位
float 单精度浮点 32位
char 字符型 16 位
boolean 布尔型 1位

public class practice {
    public static void main(String[] args){
        int a=10;
        float b=32;
        char c='c';
        String d="hello world!";//String为一个类，不是基本变量
        System.out.println(d);
    }
}

静态常量（一般用final修饰）

强制类型转换

public class practice {
    public static void main(String[] args){
        char a='a';
        System.out.println((int)a);        //强制转类型即变量前面加（变量类型），由于位数问题，可能会导致精度降低。
    }
}

自动类型转换

public class practice {
    public static void main(String[] args){
        //必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，
        char a='a';
        System.out.println((int)a);
        int b=a+1;
        System.out.println(b);
    }
}

局部变量

public class practice {
    public void student(){
            int age=18;//局部变量声明在方法、构造方法或者语句块中；
            String name="Kiki";//局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁
            String sex="Male";//局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
            System.out.println(age);
        }
    public static void main(String[] args){
        practice s=new practice();
        s.student();
    }
}

实例变量

1、实例变量声明在一个类中，但在方法、构造方法和语句块之外；
2、实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
3、访问修饰符可以修饰实例变量；
移位运算

public class practice {
    public static void main(String[] args){
        int a=5;//b(5)==111,右移2位，得1；
        System.out.println(a>>2);
    }
}

短路逻辑运算符（&&）
当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

？：操作

public class practice {
    public static void main(String[] args){
        int a=2;
        boolean b=(a==2)?true:false;//如果第一个表达式成立，执行第二个表达式，否则执行第三个。
        System.out.println(b);
    }
}

实例化对象检测

public class practice {
    public static void main(String[] args){
        practice p=new practice();
        System.out.println(p instanceof practice);//变量 instanceof 类    返回boolean；
    }
}

Math库

public class practice {
    public static void main(String[] args){
        int x=5,y=6;
        System.out.println(Math.max(x,y));
        System.out.println(Math.log(1));
        System.out.println(Math.exp(0));//e的0次方
        System.out.println(Math.abs(-5));//-5的绝对值
        System.out.println("sin（90°）="+Math.sin(Math.PI/2));
        System.out.println("asin(1)="+Math.asin(1));
    }
}

Charcter类

public class practice {
    public static void main(String[] args){
        char a='a';
        char aa='A';
        char b='2';
        char c=' ';
        System.out.println(Character.isLowerCase(a));
        System.out.println(Character.isUpperCase(aa));
        System.out.println(Character.isDigit(b));
        System.out.println(Character.isWhitespace(c));
    }
}

String类

public class practice {
    public static void main(String[] args){
        String s="This is a String";
        String s1=new String("This is also a string");//String的两种构造方式。
    }
}

“==”与“equals”

public class practice {
    public static void main(String[] args){
        String s1="This is a String";
        String s2="This is a String";
        String s3=new String("This is a String");
        System.out.println("s的长度：" + s1.length());
        System.out.println("s第1位的字符为："+s1.charAt(1));
        System.out.println(s1==s2);//"=="判断地址是否相同
        System.out.println(s2==s3);
        System.out.println(s1.equals(s2));//”.equals“判断字符串内容是否相同
        System.out.println(s1.equals(s3));

    }
}

常用函数（Sring不可修改，StringBuffer可修改）

public class practice {
    public static void main(String[] args){
        StringBuffer s=new StringBuffer("hello world");
        String s1="world";
        s.append("!");
        s.delete(11,12);
        s.reverse();//反置；
        System.out.println(s);
        s.reverse();
        System.out.println("world第一次出现的位置为："+s.indexOf(s1));
    }
}

一维数组

public class practice {
    public static void main(String[] args){
        int[] matrix=new int[10];//创建并初始化
        int[] matrix1=new int[]{1,2,3,4,5,6,7,8,9,10};//直接分配
        for(int i=0;i<matrix.length;i++){
            matrix[i]=i;
        }
    }
}

排序

import java.util.Arrays;

public class practice {
    public static void main(String[] args){
        int[] matrix=new int[]{3,2,6,8,1};//创建并初始化
        Arrays.sort(matrix);//排序
        for(int i=0;i<matrix.length;i++){
            System.out.print(matrix[i]+" ");
        }
    }
}

继承

class People{
    int age;
    String name;
    String sex;
    public void set(int age,String name,String sex){
        this.age=age;
        this.name=name;
        this.sex=sex;
    }
}
class Student extends People{
/*extends继承的关键词。可理解为，学生、老师都属于人类。
子类拥有父类非private的所有变量和方法。
一个父类可以有多个子类，一个子类只能有一个父类I（一个父亲可以有多个儿子，一个儿子只能有一个父亲）。
 */
}
class Teacher extends People{

}
public class practice {
    public static void main(String[] args){
        People p=new People();
        p.set(25,"Amy","Female");
        Student s=new Student();
        s.set(18,"kiki","Male");
        Teacher t=new Teacher();
        t.set(43,"Lucy","Female");
    }
}

重写

class People{
    public void f(){
        System.out.println("I am a people.");
    }
}
class Student extends People{
    public void f(){
        System.out.println("I am a student.");
    }
}
class Teacher extends People{
    public void f(){
        System.out.println("I am a teacher.");
    }
}
/*重写：子类与父类的函数名、参数完全相同
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在
子类中重写该方法就不能声明为 protected。
*/
public class practice {
    public static void main(String[] args){
        People p=new People();
        Student s=new Student();
        Teacher t=new Teacher();
        p.f();
        s.f();
        t.f();
    }
}

如需在子类中调用父类的方法，使用（super.）

class Student extends People{
    public void f(){
        System.out.println("I am a student.");
        super.f();
    }
}

重载

1. 被重载的方法必须改变参数列表(参数个数或类型不一样)；
2. 被重载的方法可以改变返回类型；
3. 被重载的方法可以改变访问修饰符；
4. 方法能够在同一个类中或者在一个子类中被重载。
5. 无法以返回值类型作为重载函数的区分标准。

class People{
    public int  f(int x,int y){
        return x+y;
    }
}
class Student extends People{
    public double f(double x,double y){
        return x+y;
    }
}
class Teacher extends People{
    public int  f(int x,int y,int z){
        return x+y+z;
    }
}
public class practice {
    public static void main(String[] args){
        People p=new People();
        Student s=new Student();
        Teacher t=new Teacher();
        s.f(1,2);//调用父类int型加法
        s.f(2.4,5.7);//调用子类double型加法
        t.f(2,3);//调用父类2个未知数加法
        t.f(1,2,3);//调用子类3个未知数加法
    }
}