Java学习笔记

博主：酱油瓶
发布时间：2021 年 05 月 09 日
2031 次浏览
暂无评论
11049字数
分类：学习软件工程

# Java基础语法

## Java标识符

- 开始 A-z  $ _
- 后面可以A-z  $ _ 或数字任意组合
- 不能使用关键字
- 大小写敏感
- 可以使用中文名但不建议

## 数据类型

1. 强类型语言
2. 两大类数据类型

- 最好完全避免使用浮点数进行比较

## 类型转换

- 强制转换 `（类型）变量名`  高→低
- 自动转换 低→高

## 变量和常量

### 变量

```java
public class Demo08 {
    //实例变量
    String name;
    int age;

//类变量
    static int salary = 3000;

public static void main(String[] args) {

//局部变量 必须声明和初始化值
        int i =10;
        System.out.println(i);

//变量类型 变量名字 = new Demo08()
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.name);
        System.out.println(demo08.age);

//类变量 static
        System.out.println(salary);
    }
}
```

### 常量

```java
//修饰符不存在先后顺序
static final double PI=3.14;
```

### 变量命名规范

- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则—— 除第一个单词外，后面单词首字母大写 ：monthSalary
- 局部变量：首字母小写和驼峰原则
- 常量：大写与下划线：MAX_VALUE
- 类名：首字母小写和驼峰原则：Man,GoodMan
- 方法名首字母小写和驼峰原则：run(),runRun()

## 运算符

```java
        int a = 10;
        int b = 20;

a += b; //a=a+b
        a -= b; //a=a-b

System.out.println(a+b);

//字符串连接符 +   String
        System.out.println(""+a+b);	//1020
        System.out.println(a+b+"");	//30
```

# Java 方法

```java
public class Demo01 {
    //修饰符 数据类型 方法名(参数类型 参数名,...)
    public static double add(double a,double b){
        //方法体
        return a+b;	//return 返回值
    }
  
     public static void main(String[] args) {
        //方法的调用
        double sum = add(10.0,20.0);
        System.out.println(sum);
    }
}

```

## 方法重载

- 方法名必须相同
- 参数列表必须不同
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载

```java
public class Demo01 {
    public static double add(double a,double b){
        return a+b;
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static void main(String[] args) {
        double sum = add(10.0,20.0);
        System.out.println(sum);
    }
}
```

## 可变参数

- 一个方法中只能指定一个可变参数，它必须是最后一个参数，任何普通的参数必须在它之前声名

```java
public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.test(123,2);
    }
    // (参数类型... 参数名)
    public void test(int... i){
        System.out.println(i[0]);//打印第一个123
    }
}
```

## 递归

- 递归即自己调用自己
- 递归结构包含两个部分
  1. 递归头：什么时候不不调用自身方法。
  2. 递归体：什么时候需要调用自身方法。

```java
public class Demo04 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }

//阶乘
    public static int f(int i){
        if (i==1){
            return 1;	//递归头
        }else {
            return i*f(i-1);	//递归体
        }
    }
}
```

# Java数组

## 声明与创建

```java
        //定义一个数组
        int[] array1;   //首选
        int array2[];

array1 = new int[10];   //创建数组

int[] array3 = new int[10]; //声明与创建数组

//数组赋值
        array1[0]=1;
        array1[1]=2;
        array1[2]=3;

System.out.println(array1[0]);  //1
        System.out.println(array1[3]);  //0  默认值
```

## 数组初始化

```java
		//静态初始化：创建+赋值
        int[] a = {1,2,3,4,5,6,7};

//动态初始化,包含默认初始化
        int[] b = new int[10];
        b[0]=1;

System.out.println(b[0]);//1
        System.out.println(b[1]);//0默认初始化值
```

## 数组特点

- 数组是相同数据类型的有序集合
- 数组也是对象，数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的。如果越界，则报：

```java
   ArrayIndexOutofBounds
  ```

## 数组的使用

- for循环
- for-each循环
- 数组作方法入参
- 数组作返回值

```java
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};

//foreach循环
        for (int i : a) {
            System.out.print(i+" ");
        }
        printArray(a);//打印数组a
        int[] b=reverse(a);//反转a至b
        printArray(b);//打印数组b

}
    //打印数组
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }

//反转数组
    public static int[] reverse(int[] array){
        int[] b=new int[array.length];
        for (int i = 0,j=b.length-1; i < b.length; i++,j--) {
            b[i]=array[j];
        }
        return b;
    }
```

# Java 面向对象

## 概念

- 面向对象的本质：以类的方式组织代码，以对象的组织(封装)数据
- 三大特性：
  1. 封装
  2. 继承
  3. 多态

## 构造

```java
//Person类
public class Person {

String name;
    int age;

//快捷键：alt+insert

//1. 使用new关键字，必须要有构造
    //2. 用来初始化值
    public Person() {
    }

public Person(String name) {
        this.name = name;
    }
    //构造方法重载
    //有参构造：一旦定义了有参构造，无参构造就要显式定义
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

//Student类
public class Student {

//属性
    String name;
    int age;

//方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

//一个项目应该只存放一个main方法
public class Application {
    public static void main(String[] args) {

//类:抽象的，实例化
        //类实例化后会返回一一个自己的对象!
        //student对象就是- -个Student类的具体实例!

Student xm = new Student();

xm.name="xiaoming";
        xm.age=18;

System.out.println(xm.name);//xiaoming
        System.out.println(xm.age);//18
        xm.study();//小明在学习

//-一个类即使什么都不写，它也会存在一一个方法
        //显示的定义构造器

Person person = new Person("juju",19);
        System.out.println(person.age+person.name);//19juju

}
}

```

## 封装

- 属性私有 get / set

```java
public class Student {
    //属性私有
    private String name;//姓名
    private int age;//年龄
    private int id;//学号
    private char sex;//性别

//在IDEA中使用 Alt + Insert 中 Getter 和 Setter 
    //获得数据
    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 int getId() {
        return id;
    }

public void setId(int id) {
        this.id = id;
    }

public char getSex() {
        return sex;
    }

public void setSex(char sex) {
        this.sex = sex;
    }
}
```

## 继承

- 关键字 extends
- 在Java中，所有的类都默认直接或间接继承Object类
- Java中类只有单继承
- Ctrl+H查看关系

### super

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中!
3. super和this 不能同时调用构造方法!

### super与this

代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提
this:没哟继承也可以使用
super:只能在继承条件才可以使用
构造方法
this() ; 本类的构造
super():父类的构造!

```java
//人 ： 父类
public class Person {
    public Person(){
        System.out.println("Person的无参构造执行了");
    }
    public Person(String name){
        System.out.println("Person有参构造执行了");
    }
    protected String name = "A";
    //私有的东西无法被继承
    public void print(){
        System.out.println("Person");
    }
}

//学生 是 人： 子类
//继承父类所有方法
public class Student extends Person{
    public Student(){
    super("name");
        System.out.println("Student无参构造执行了");
    }
    private String name="B";

public void print(){
        System.out.println("Student");
    }
     public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
     }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test1();
		/*运行结果：
		Person有参构造执行了
		Student无参构造执行了
		Student
		Student
		Person*/
    }
}
```

##　重写

需要有继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符： 范围可以扩大： public > Protected > Default > private
4. 抛出的异常：范围，可以被缩小，但不能扩大

重写，子类的方法和父类必须要一致，方法体不同！

```java
//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B=>test");
    }
}

public class A extends B {
    //override 重写
    @Override //注解:有功能的注释!
    public void test() {
        System.out.println("A=>test");;
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法

a.test();//A=>test
        b.test();//A=>test
    }
}
```

###　为什么要重写

1. 父类的功能，子类不一定需要，或者不一定满足

Alt + Insert ；override;

## 多态

### 注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类有联系

```java
   //类型转换异常
   ClassCastException
   ```
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ *Father f1 = new Son()*

### 方法不能重写

1. ***static*** 方法，属于类，不属于实例
2. ***final*** 常量
3. ***private*** 方法

```java
public class Person {
    public void run(){
        System.out.println("Person run");
    }
}

public class Student extends Person {
    public void run(){
        System.out.println("Student run");
    }
    public void eat(){
        System.out.println("eat");
    }
}

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了：父类的引用指向子类

//Student 能调用的方法都是自己的或是继承父类的
        Student s1 = new Student();
        //Person 父亲类，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s1.run();//Student run
        s2.run();//Student run
        ((Student)s2).eat();//eat
        s1.eat();//eat

}
}
```

### 总结

1. 父类引用指向子类的对象
2. 把子咧转换为父类，向上转型；
3. 把父咧转换为子类，向下转型；强制转换
4. 方便方法的调用，减少重复的代码

## 抽象类

1. 不能new抽象类，只能通过子类去实现
2. 抽象类中可以写普通的方法
3. 抽象方法必须在抽象类中

```java
//abstract 抽象类：类
public abstract class Action {

//abstract，抽象方法，只有方法名，没有方法的实现
    public abstract void doSomething();

}
```

## 接口

```java
//定义一个接口
public interface NameOfInterface{
    //常量 public static final
    int AGE = 99;
    //接口中的所有定义方式其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
```

### 作用：

1. 约束
2. 定义一些方法，让不同的人实现
3. 方法 public abstract
4. 常量 public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements 可以实现多个接口
7. 必须重写接口中的方法

## 其他

- 代码调用顺序

```java
public class Person {
    //2：赋初始值
    {
        System.out.println("匿名代码块");
    }
    //1:只执行一次
    static{
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }

public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("================");
        Person person2 = new Person();
    }
}
```

- 静态字段与静态方法

```java
public class Student {

private static int age;//静态变量
    private double score;//非静态变量

public static void go(){
    }

public void run(){
    go();
    }

public static void main(String[] args) {
        Student s1 = new Student();

System.out.println(Student.age);//类的变量
        System.out.println(s1.age);//实例的变量
        System.out.println(s1.score);

go();
    }
}
```

最后修改：2022 年 06 月 03 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

Java学习笔记

酱油瓶 • 2021 年 05 月 09 日

# Java基础语法

## Java标识符

- 开始 A-z  $ _
- 后面可以A-z  $ _ 或数字任意组合
- 不能使用关键字
- 大小写敏感
- 可以使用中文名但不建议

## 数据类型

1. 强类型语言
2. 两大类数据类型

- 最好完全避免使用浮点数进行比较

## 类型转换

- 强制转换 `（类型）变量名`  高→低
- 自动转换 低→高

## 变量和常量

### 变量

```java
public class Demo08 {
    //实例变量
    String name;
    int age;

//类变量
    static int salary = 3000;

public static void main(String[] args) {

//局部变量 必须声明和初始化值
        int i =10;
        System.out.println(i);

//变量类型 变量名字 = new Demo08()
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.name);
        System.out.println(demo08.age);

//类变量 static
        System.out.println(salary);
    }
}
```

### 常量

```java
//修饰符不存在先后顺序
static final double PI=3.14;
```

### 变量命名规范

## 运算符

```java
        int a = 10;
        int b = 20;

a += b; //a=a+b
        a -= b; //a=a-b

System.out.println(a+b);

//字符串连接符 +   String
        System.out.println(""+a+b);	//1020
        System.out.println(a+b+"");	//30
```

# Java 方法

```

## 方法重载

- 方法名必须相同
- 参数列表必须不同
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载

## 可变参数

- 一个方法中只能指定一个可变参数，它必须是最后一个参数，任何普通的参数必须在它之前声名

## 递归

- 递归即自己调用自己
- 递归结构包含两个部分
  1. 递归头：什么时候不不调用自身方法。
  2. 递归体：什么时候需要调用自身方法。

```java
public class Demo04 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }

//阶乘
    public static int f(int i){
        if (i==1){
            return 1;	//递归头
        }else {
            return i*f(i-1);	//递归体
        }
    }
}
```

# Java数组

## 声明与创建

```java
        //定义一个数组
        int[] array1;   //首选
        int array2[];

array1 = new int[10];   //创建数组

int[] array3 = new int[10]; //声明与创建数组

//数组赋值
        array1[0]=1;
        array1[1]=2;
        array1[2]=3;

System.out.println(array1[0]);  //1
        System.out.println(array1[3]);  //0  默认值
```

## 数组初始化

```java
		//静态初始化：创建+赋值
        int[] a = {1,2,3,4,5,6,7};

//动态初始化,包含默认初始化
        int[] b = new int[10];
        b[0]=1;

System.out.println(b[0]);//1
        System.out.println(b[1]);//0默认初始化值
```

## 数组特点

- 数组是相同数据类型的有序集合
- 数组也是对象，数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的。如果越界，则报：

```java
   ArrayIndexOutofBounds
  ```

## 数组的使用

- for循环
- for-each循环
- 数组作方法入参
- 数组作返回值

```java
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};

}
    //打印数组
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }

# Java 面向对象

## 概念

- 面向对象的本质：以类的方式组织代码，以对象的组织(封装)数据
- 三大特性：
  1. 封装
  2. 继承
  3. 多态

## 构造

```java
//Person类
public class Person {

String name;
    int age;

//快捷键：alt+insert

//1. 使用new关键字，必须要有构造
    //2. 用来初始化值
    public Person() {
    }

//Student类
public class Student {

//属性
    String name;
    int age;

//方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

//一个项目应该只存放一个main方法
public class Application {
    public static void main(String[] args) {

//类:抽象的，实例化
        //类实例化后会返回一一个自己的对象!
        //student对象就是- -个Student类的具体实例!

Student xm = new Student();

xm.name="xiaoming";
        xm.age=18;

System.out.println(xm.name);//xiaoming
        System.out.println(xm.age);//18
        xm.study();//小明在学习

//-一个类即使什么都不写，它也会存在一一个方法
        //显示的定义构造器

Person person = new Person("juju",19);
        System.out.println(person.age+person.name);//19juju

}
}

```

## 封装

- 属性私有 get / set

```java
public class Student {
    //属性私有
    private String name;//姓名
    private int age;//年龄
    private int id;//学号
    private char sex;//性别

public int getAge() {
        return age;
    }

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

public int getId() {
        return id;
    }

public void setId(int id) {
        this.id = id;
    }

public char getSex() {
        return sex;
    }

public void setSex(char sex) {
        this.sex = sex;
    }
}
```

## 继承

- 关键字 extends
- 在Java中，所有的类都默认直接或间接继承Object类
- Java中类只有单继承
- Ctrl+H查看关系

### super

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中!
3. super和this 不能同时调用构造方法!

### super与this

public void print(){
        System.out.println("Student");
    }
     public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
     }
}

##　重写

需要有继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符： 范围可以扩大： public > Protected > Default > private
4. 抛出的异常：范围，可以被缩小，但不能扩大

重写，子类的方法和父类必须要一致，方法体不同！

```java
//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B=>test");
    }
}

public class A extends B {
    //override 重写
    @Override //注解:有功能的注释!
    public void test() {
        System.out.println("A=>test");;
    }
}

a.test();//A=>test
        b.test();//A=>test
    }
}
```

###　为什么要重写

1. 父类的功能，子类不一定需要，或者不一定满足

Alt + Insert ；override;

## 多态

### 注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类有联系

```java
   //类型转换异常
   ClassCastException
   ```
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ *Father f1 = new Son()*

### 方法不能重写

1. ***static*** 方法，属于类，不属于实例
2. ***final*** 常量
3. ***private*** 方法

```java
public class Person {
    public void run(){
        System.out.println("Person run");
    }
}

public class Student extends Person {
    public void run(){
        System.out.println("Student run");
    }
    public void eat(){
        System.out.println("eat");
    }
}

}
}
```

### 总结

1. 父类引用指向子类的对象
2. 把子咧转换为父类，向上转型；
3. 把父咧转换为子类，向下转型；强制转换
4. 方便方法的调用，减少重复的代码

## 抽象类

1. 不能new抽象类，只能通过子类去实现
2. 抽象类中可以写普通的方法
3. 抽象方法必须在抽象类中

```java
//abstract 抽象类：类
public abstract class Action {

//abstract，抽象方法，只有方法名，没有方法的实现
    public abstract void doSomething();

}
```

## 接口

### 作用：

## 其他

- 代码调用顺序

public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("================");
        Person person2 = new Person();
    }
}
```

- 静态字段与静态方法

```java
public class Student {

private static int age;//静态变量
    private double score;//非静态变量

public static void go(){
    }

public void run(){
    go();
    }

public static void main(String[] args) {
        Student s1 = new Student();

System.out.println(Student.age);//类的变量
        System.out.println(s1.age);//实例的变量
        System.out.println(s1.score);

go();
    }
}
```

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

Java学习笔记

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款