Java基础笔记

• 在dos环境下编译Java文件

• 在dos环境下执行Java类
  在类目录下执行java 类名
  如果出现不存在xxx.class，将含有class文件的目录添加到环境变量的classpath中，或者将classpath删除
• public类只能在一个Java文件中存在一个

• 标识符

可以用来标识类名，接口名，变量名，方法名，常量名。
规则：
只能由数字、字母、下划线、美元符号组成，不能有其他字符（可以使用汉字，但一般不用）
不能以数字开头
不能使用Java中保留的关键字
区分大小写
没有长度限制
命名规范：
类名、接口名 首字母大写，之后每个单词首字母大写
变量名、方法名 首字母小写，之后每个单词首字母大写
常量名全部大写，单词间用_隔开

• 关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，进行程序调试
boolean	布尔类型
break	提前跳出这个快
byte	字节类型
case	switch语句之中，表示其中一个分支
catch	用在异常处理中，用来捕捉异常
char	字节类型
class	声明一个类
const	无具体含义
continue	回到一个块的开始处
default	默认，例如用在switch语句中，表明一个默认的分支
do	用在do-while循环中
double	双精度浮点型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类，常见的有类和接口
final	不可变的量，常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	单精度型
for	一种循环结构的引导词
goto	没有具体含义
if	条件语句的引导词
implements	声明一个类实现了给定的接口
import	声明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	整数类型
interface	接口
long	长整数类型
native	声明一个方法是由与计算机相关的语言（如C C++等）实现的
new	用来创建新的实例对象
package	包
private	私有模式
protected	保护模式
public	公用模式
return	从成员方法中返回数据
short	短整数型
static	静态属性
strictfp	声明FP_strict（单精度或双精度浮点型）表达式遵循IEEE 754算是规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步的发生变化
while	用在循环结构中

• 变量
  变量的定义要在类中，访问时就近原则，方法中的变量不共享给其他方法。
  未初始化的变量不能直接输出。
  
  不能在static方法中引用方法以外的非static变量
  
  可以同时声明多个相同类型的变量
  
  变量的分类
  
  作用域：记住出了大括号就不认识了。
  方法中不能声明static变量
  
  静态方法只能引用静态变量
  
  变量在不同的域，可以同名
  
  声明long型变量时后边加L
  声明flout型变量时后边加F
• 八个基本数据类型

数据类型	长度
byte 字节型	1
short 短整型	2
int 整型	4
long 长整型	4
float 单精度	4
double 双精度	8
boolean 布尔型	1
char 字符型	2
BigDecimal、String不是基本数据类型
一个数字占一个字符，一个字母占两个字符，一个汉字占四个字符

• 进制
  进制的表示

符号	含义
0b	二进制
0	八进制
不加	十进制
0x	十六进制

• 运算符

运算符	包含
算术运算符	+、-、*、/、%、++、–
关系运算符	>、>=、<、<=、==、!=
逻辑运算符	&、丨、!、&&（str != null 时才执行） 、丨丨
赋值运算符	=、+=、-=、*=、/=、%=、^=、&=/、丨=、<<=、>>=
位运算符	&（按位与）、丨（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（带符号右移）、>>>（无符号右移）
条件（三目）运算符	布尔表达式?表达式1:表达式2
字符串连接运算符	+
其他运算符	instanceof、new
注意小括号的应用
++i：先加一再用
i++：先调用一次之后再加一
两个int型做“/”运算时，小数点后的去掉（模除同理）
int型与其他可以保留小数的类型做“/”运算时，保留小数（模除同理）

• 循环语句

if else语句

public static void main(String[] args) {
        String a = "下雨";
        if(a == "下雨"){
            System.out.println("今天有雨，请带伞");
        } else if (a=="中雪"){
            System.out.println("天气寒冷，请注意保暖");
        } else {
            System.out.println("今天晴，放心出门吧");
        }
    }

switch case语句

public static void main(String[] args) {
        float score = 70.2F;
        switch ((int) score){//char、byte、short、int、Character、Byte、Short、Integer、String 或枚举
            case 60: case 70: case 80: case 90: case 100:
                System.out.println("及格");
                break;
            case 50:
                System.out.println("不及格");
            default://可以现在任意位置，都是最后执行
                System.out.println("数据出错");
        }
    }

for语句

for (int i = 1;i<=100;i++){
            System.out.println("你好"+i);
        }

可以给本次循环命名 aaa:for(…)为本次循环为aaa循环，通常与break（break:aaa）连用，跳出指定循环。
利用for循环实现99乘法表

public static void main(String[] args) {
        for (int i = 1;i<=9;i++){
            for (int j = 1;j<=i;j++){
                System.out.print(i+"*"+j+"="+i*j+" ");
            }
            System.out.println();
        }
    }

while循环

public static void main(String[] args) {
        int i = 0;
        while (i<10){
            i++;
            System.out.println(i);
        }
    }

do while循环（循环体至少执行一次）

public static void main(String[] args) {
        int i = 0;
        do {
            i++;
            System.out.println(i);
        } while (i<-1);
    }

break和continue：都是用来控制循环的，break用来终止循环的执行，continue用来终止本次循环。

 public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("--------");
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                continue;
            }
            System.out.println(i);
        }
    }

• 方法

//无返回值
public static void sumInt(int a,int b){
//public static是修饰符列表
//void是返回值类型（void表示无返回参数）
//sumInt是方法名
//(int a,int b)是形式参数，是局部变量
        int c = a + b;
        System.out.println(c);
    }

//有返回值
public static int sum1(int a,int b){
        return a+b;//return一旦执行，该方法就执行结束
    }

• 方法的调用
  调用本类中的方法

public class test {
    public static void main(String[] args) {
        test.sumInt(10,10);//类名.方法名（类名可省略）
        sumInt(1,1);
    }
    public static void sumInt(int a,int b){
        int c = a + b;
        System.out.println(c);
    }
}

调用其他类中的方法

类1
public class sum {
    public void sumDouble(double d1,double d2){
    //可以带有static修饰符
        double ds = d1+d2;
        System.out.println(ds);
    }
}

类2
public class test {
    public static void main(String[] args) {
        sum s = new sum();//先创建对象
        s.sumDouble(1,2);//通过对象调用方法

		//如果只调用一次，可以直接使用 类名.方法名调用
		sum.sumDouble(2,3);
    }
}

• 堆和栈和方法区
  方法区存类信息、常量、静态变量，栈从方法区中获得方法；堆存放对象实例
• 方法重载

public class test {
    public static void main(String[] args) {
        sum(1,2);
        System.out.println(sum(1.1,2.1));
    }
    //区别条件是形参类型或数量不同
    public static void sum(int a,int b){
        int c = a + b;
        System.out.println(c);
    }
    public static double sum(double a,double b){
        return a+b;
    }
}

• 方法递归：调用自身的方法

public class test {
    public static void main(String[] args) {
        int n = 5;
        int result = accumulate(n);
        System.out.println("1加到"+n+"="+result);
    }
    public static int accumulate(int n){
        if (n==1){
            return 1;
        }
        return n+accumulate(n-1);
    }
}

• 类
  [修饰符] class 类名{
  类体 = 属性 + 方法
  }

public class Student {
//    学号
    int no;
//    姓名
    String name;
//    年龄
    int age;
//    性别
    boolean sex;
}

• 对象的创建及使用

public static void main(String[] args) {
//        创建一个学生对象
        Student s1 = new Student();
//        赋值
        s1.no = 10;
        s1.name = "张三";
        s1.sex = false;
        s1.age = 21;
//        再创建一个学生对象
        Student s2 = new Student();

        System.out.println(s1.no);
        System.out.println(s1.name);
        System.out.println(s1.sex);
        System.out.println(s1.age);
    }

• 构造方法
  不能写返回值类型，void也不能写

public class Date {
//    创建无参构造方法
    public Date(){
        System.out.println("无参构造方法");
    }
//    创建有参构造方法
    public Date(int year){
        System.out.println("有参构造方法");
    }
}


public class Test {
    public static void main(String[] args) {
//        调用无参构造方法
        Date d1 = new Date();
//        调用有参构造方法
        Date d2 = new Date(2010);
    }
}

一旦创建了有参构造方法，但没重写无参构造方法时，无参构造方法不能直接调用。

• 面向对象的三大特征
  封装、继承、多态

• 封装（信息隐藏）
  使用private修饰符

public class Student {
//    学号  使用private修饰
    private int no;
//    姓名
    private String name;
//    年龄
    private int age;
//    创建get和set方法
    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}



public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("zhangsan");
        s1.setAge(21);
        s1.setNo(123);
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
        System.out.println(s1.getNo());
    }
}

• this在实例方法中的使用
  哪个对象调用这个方法，方法中的this就代表哪个对象
  this不能在static方法中使用，因为this指向的是当前对象，static方法是类方法，类启动后优先执行，static方法执行时对象还没有创建。

public class Student {
//    姓名
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student(String _name){
        name = _name;
    }

    public void school(){
        System.out.println("school---"+this);
    }
}




public class Test {
    public static void main(String[] args) {
        Student jack = new Student("jack");
        System.out.println("main---"+jack);
        jack.school();
    }
}


输出（两个地址相同）
main---Student@1b6d3586
school---Student@1b6d3586

this可以省略，有些地方不得省略

public void setName(String name) {
//      this是调用这个方法的对象
//		对象name   =   形参中的name
        this.name = name;
    }

• this在构造方法中的使用
  在无参构造方法中用this调用有参构造方法，实现数据初始化

public class Date {
    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    private int year;
    private int month;
    private int day;

    public Date(){
        this(1999,1,1);//必须在第一行，在其他行无效，目的是避免代码重复
    }
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}


public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getYear()+"."+date.getMonth()+"."+date.getDay());
        Date date1 = new Date(2020,3,2);
        System.out.println(date1.getYear()+"."+date1.getMonth()+"."+date1.getDay());
    }
}

• static静态变量
  静态变量在类加载时初始化，存储在方法区中，并不是当做对象中的元素存放在堆中，值是固定的不能通过对象修改

public class Man {
    String name;
    static boolean sex = true;
    public Man(String name) {
        this.name = name;
    }
    public static void show(){
        System.out.println("--------");
    }
}


public class Test {
    public static void main(String[] args) {
//        静态变量的正式访问方法
        System.out.println(Man.sex);
//        静态方法的正式访问方法
        Man.show();
//      不建议使用如下方法
        Man tom = new Man("tom");
        System.out.println(tom.sex);
        tom.show();
    }
}

• 静态代码块
  静态代码块优先自上而下执行，且只执行一次
  静态代码块不能引用实例变量，但可以引用静态变量，且静态变量位置在静态代码块之前

public class Test {
    static {
        System.out.println(1);
    }
    public static void main(String[] args) {
        System.out.println(2);
    }
    static {
        System.out.println(3);
    }
}

输出
1
3
2

• 继承

java中只支持单继承，不支持多继承，c++中支持多继承，但可以通过间接继承来实现多继承 如A继承B，C继承A，从而实现C继承A和B
java默认继承Object类，通常不写
存在耦合度高的问题，即为当A类变化是，连带B类也发生变化
私有方法和构造方法不能被继承
语法：

class 类名 extends 父类名{
	类体;
}

//普通学生类
public class Student {
//    姓名
    private String name;
//    语文成绩
    private double yuwen;
//    数学成绩
    private double shuxue;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getYuwen() {
        return yuwen;
    }

    public void setYuwen(double yuwen) {
        this.yuwen = yuwen;
    }

    public double getShuxue() {
        return shuxue;
    }

    public void setShuxue(double shuxue) {
        this.shuxue = shuxue;
    }
}


//体育生类
public class TiyuStudent extends Student {
//    特有属性
//    跳高成绩
    private double tiaogao;
//    铅球成绩
    private double qianqiu;

    public double getTiaogao() {
        return tiaogao;
    }

    public void setTiaogao(double tiaogao) {
        this.tiaogao = tiaogao;
    }

    public double getQianqiu() {
        return qianqiu;
    }

    public void setQianqiu(double qianqiu) {
        this.qianqiu = qianqiu;
    }
}


//测试体育生类
public class Test {
    public static void main(String[] args) {
        TiyuStudent tiyuStudent = new TiyuStudent();
        tiyuStudent.setName("zs");
        tiyuStudent.setShuxue(99);
        tiyuStudent.setYuwen(95);
        tiyuStudent.setTiaogao(19);
        tiyuStudent.setQianqiu(18);

        System.out.println(tiyuStudent.getName()+"----"+tiyuStudent.getYuwen()+"----"+tiyuStudent.getShuxue()+"----"+
                tiyuStudent.getTiaogao()+"----"+tiyuStudent.getQianqiu());
    }
}


//如果使用有参构造方法
//student类中添加
public Student(String name, double yuwen, double shuxue) {
        this.name = name;
        this.yuwen = yuwen;
        this.shuxue = shuxue;
    }
//tiyustudent类中添加
public TiyuStudent(String name, double yuwen, double shuxue) {
        super(name, yuwen, shuxue);
    }
//在测试类中赋值时
TiyuStudent tiyuStudent = new TiyuStudent("zs",20,20);
        tiyuStudent.setTiaogao(19);
        tiyuStudent.setQianqiu(18);

• 方法重写
  继承父类之后，子类重写父类中某些方法的方法体
  私有方法和构造方法不能被继承，所以也不能被覆盖，静态方法不存在覆盖

//People类
public class People {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void speakHi(){
        System.out.println(name+"和别人打招呼");
    }
}


//ChinaPeople类，继承People类，并且重写speakHi方法
public class ChinaPeople extends People{
    public void speakHi(){
        System.out.println("你好，我是"+getName());
    }
}


//测试类
public class Test {
    public static void main(String[] args) {
        ChinaPeople p1 = new ChinaPeople();
        p1.setName("zhangsan");
        p1.speakHi();
    }
}

//输出内容为重写后的方法体处理的内容

• 多态
  多态是同一个行为具有多个不同标现形势或形态的能力，即同一个行为发生在不同对象上会产生不同的效果。
  java中的多态分为向上转型（子类型转换为父类型）和向下转型（父类型转换为子类型）
  向下转型的目的是解决因向上转型而无法调用子类中的方法的问题

//学生类
public class Student {
//    姓名
    private String name;
//    语文成绩
    private double yuwen;
//    数学成绩
    private double shuxue;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getYuwen() {
        return yuwen;
    }

    public void setYuwen(double yuwen) {
        this.yuwen = yuwen;
    }

    public double getShuxue() {
        return shuxue;
    }

    public void setShuxue(double shuxue) {
        this.shuxue = shuxue;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", yuwen=" + yuwen +
                ", shuxue=" + shuxue +
                '}';
    }

    public Student(String name, double yuwen, double shuxue) {
        this.name = name;
        this.yuwen = yuwen;
        this.shuxue = shuxue;
    }
}


//体育生类
public class TiyuStudent extends Student {
//    特有属性
//    跳高成绩
    private double tiaogao;
//    铅球成绩
    private double qianqiu;

    public TiyuStudent(String name, double yuwen, double shuxue, double tiaogao, double qianqiu) {
        super(name, yuwen, shuxue);
        this.tiaogao = tiaogao;
        this.qianqiu = qianqiu;
    }

    public double getTiaogao() {
        return tiaogao;
    }

    public void setTiaogao(double tiaogao) {
        this.tiaogao = tiaogao;
    }

    public double getQianqiu() {
        return qianqiu;
    }

    public void setQianqiu(double qianqiu) {
        this.qianqiu = qianqiu;
    }
	public void spot(){
        System.out.println("we can do anything!!");
    }

    @Override
    public String toString() {
        return "TiyuStudent{"+"name'"+"="+super.getName()+'\'' +
                ", yuwen=" + super.getYuwen() +
                ", shuxue=" + super.getShuxue()+
                ", tiaogao=" + tiaogao +
                ", qianqiu=" + qianqiu +
                '}';
    }

}

//测试类
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("zhansan",99,98);
//        实现多态，向上转型
        Student s2 = new TiyuStudent("lisi",70,75,19,18);
//        s2.sopt();  无法直接调用体育生中的方法
//        需要向下转型，将学生s2转型为体育生
        TiyuStudent s3 = (TiyuStudent) s2;
        s3.spot();

        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println(s3.toString());
    }
}


we can do anything!!
Student{name='zhansan', yuwen=99.0, shuxue=98.0}
TiyuStudent{name'=lisi', yuwen=70.0, shuxue=75.0, tiaogao=19.0, qianqiu=18.0}
TiyuStudent{name'=lisi', yuwen=70.0, shuxue=75.0, tiaogao=19.0, qianqiu=18.0}

• 封装继承多态的综合应用
  主人喂狗时啃骨头，喂猫时吃鱼

//宠物类
public class Pet {//封装成为宠物类
    String name;
    public Pet(String name) {
        this.name = name;
    }
    public void eat(){
    }
}


//猫类
public class Cat extends Pet{//继承pet类
    public Cat(String name) {
        super(name);
    }
    public void eat(){//重写eat方法
        System.out.println(name+"在吃鱼");
    }
}


//狗类
public class Dog extends Pet{
    public Dog(String name) {
        super(name);
    }
    @Override
    public void eat() {
        System.out.println(name+"在啃骨头");
    }
}


//主人类
public class Master {
    public void feed(Pet pet){
        System.out.println("主人开始喂食");
        pet.eat();
        System.out.println("主人喂食完毕");
    }
}


//测试类
public class Test {
    public static void main(String[] args) {
        Pet dog = new Dog("二哈");//多态
        Pet cat = new Cat("点点");
        Master master = new Master();
        master.feed(dog);
        master.feed(cat);
    }
}

• super
  super表示当前对象从父类继承过来的那部分特征
  super不能在静态方法中使用
  super()调用父类的无参构造
  super.xxx()调用父类的xxx方法
  例子参考前文
• 参考动力节点JavaSE零基础讲义