Java基础学习部分笔记

最新推荐文章于 2024-07-14 22:18:32 发布

codeː̗̀(ꙨꙨ)ː̖́bird

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量149

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weixin_43745496/article/details/105766647

版权

Java怎么执行的

.exe和.class的区别

.exe是win系统特有的
.class字节码文件是跑在jvm上的
- 特殊的可执行文件，需要jvm
- 优点：跨平台
- 缺点：过于依赖虚拟机

模拟执行

//假如此时有一个Test.java文件
public class Test{
    //main函数：程序入口点
    public static void main(String[] args){
        System.out.println("Hello!");
    }
}

执行过程如下：

javac Test.java
java Test
Hello!

Package

包名：com.公司.模块（**不能用复数！！！**不能tools！！！）
eg. com.microsoft.demo
本质：“包”就是“文件夹”
定位
```
package com.microsoft.demo
```

导包

import com.google.* 	//*代表全部导入

java.lang包、java.io包是java自带的，包括了很多基础功能
- 不用导，是亲孩子
- 像常用的java.util，是需要导的（eg.Random）

注释和文档

生成Java文件的API
- 网上查阅JavaDoc的详解，都找得到
  - @author
  - @since
  - @version
- 指令

javadoc Main.java

打开生成API的目录——index.html
方法外部注释一定要用/,不要用//**
方法内部注释，单行用//，多行用/*（在语句上面写，且//后面加空格）
所有类都要加上创作者和日期
特殊注释标记（标记人，标记时间，[预计处理时间]）
- TODO：需要实现，但还未实现
- FIXME：错误代码，无法工作，需要纠正

注意事项

常量

常量定义不同于c/c++
- c/c++：const
- Java：final

字符串

格式化输出
- System.out.printf();（同C语言）
格式化创建
- String.format();
等等一系列操作，一定要下功夫，很重要！包括正则表达式。
为了开发的友好，隐含了’\0’
- ‘\0’的作用——结束符，堵住字符串，不然会“烫烫烫”

自动类型转换

从低到高：byte->short->char->int->long->float->double
《主角与配角》小品（朱时茂、陈佩斯）
- 前半段：int与char
- 后半段：String与char——有函数不用
- 能String就不要char

数组

初始化

int[] arr = {1,2,3};	//不同于C
int arr[] = {1,2,3};	//也可以，但不是首选

分配方式——对象

int[] arr = new int[5];		//类似于malloc()

数组的length是变量，不用括号！

以上都是静态数组，Java不常用，因为无法扩容！！

Arrays.sort(arr);	//排序方法
Arrays.binarySearch(val);	//二分查找
Arrays.fill(arr,-1);	//类似c的memset(),用来初始化

动态的内存分配
很多方法可以调用

增强for循环——For Each

for(int num:list){
	System.out.println(num);
}

方法的重载

方法名字相同
参数不同
- 个数
- 类型
举例：求和函数

public static int sum(int x,int y){
	return x + y;
}
public static double sum(int x,int y){
	return x + y;
}
public static int sum(int x,int y,int z){
	return x + y + z;
}

优点——一个名字闯天下

面向过程——POP

走一步看一步
目标不明确的咸鱼
不适用普遍情况

面向对象——OOP

目标明确——即“对象”
程序大众化，普遍
过程弱化，不惜一切代价达成目标
举例：
- 明确目标——考取研究生
- 设计计划——复习计划
- 执行计划——读书
- 达成目标——考取
本质——站在更高层面看问题、看事物

类与对象

对象——具体
类——抽象
属性 = 变量+ 方法（包括共性、特性）
类中的变量——成员
- 它们构成了类，是类的重要组成部分
类中的方法——行为
- 谁调用的“方法”，谁就是“this”

空指针异常

个人理解——对象即指针

//分配一块Dog的内存，让指针puppy指向这块内存
Dog puppy = new Dog();
puppy.name = "Emy";
puppy.age = 2;
//正常运行
puppy.eat();
//对象销毁——指针
puppy = null;
//Error:NullPointerException
puppy.eat();

实际情况是——指针指向对象，对象才是那块内存
对象null了之后，内存被破坏，当垃圾回收了，也就是原来的内存已经GG了
要用只能再new了

垃圾回收机制

背景：在C / C ++中，程序员负责对象的创建和销毁。通常，程序员会忽略无用对象的破坏。由于这种疏忽，在某些时候，对于创建新对象，可能没有足够的内存，并且整个程序将异常终止，从而导致OutOfMemoryErrors。但是在Java中，程序员不必关心不再使用的所有那些对象。垃圾收集器会破坏这些对象。垃圾收集器是Daemon线程的最佳示例，因为它始终在后台运行。垃圾收集器的主要目标是通过破坏无法访问的对象来释放堆内存。

相当于“移民”，你人走了，档案就被撤销了，原来赋值的属性那块内存也被破坏了，就被回收掉了
在main()里，System.gc()【手动】
但其实是自动回收的，我们不用管

异常

运行时异常
- 遇到异常就停了
非运行时异常
- 编译不通过

OOP封装

public——不安全，用户可以为所欲为（比如：balance余额）

private——安全，私有的，用户没法操作

那用户怎么设置属性呢？举个例子：（年龄的设置和访问）

//用public的方法给用户提供服务
public void setAge(int age){
    if(age < 0 || age > 100){
        this.age = 0;
    }else{
        this.age = age;
    }	
}

public int getAge(){
	return this.age;
}

作用——避免用户不合法操作
实质
- setter()
- getter()
Lombok的jar包——直接加入插件就行
- @Getter
- @Setter
- @ToString
- @Data（代表了equals()、toString()、hashCode()）
- 一般写在类上，也可以单独写在属性前

OOP继承

特点：上梁不正下梁歪
在类后extends
如果前面@Setter、@Getter过了，不用再@一遍了

不能多继承（C++支持，因为“杂交”过于复杂，Java取消了）

//错的,无法同时
class Human extends Animal,Monkey;

//对的
class Monkey extends Animal;
class Human extends Monkey;

方法重写：@Override
super.父类方法()——“啃老”（@Override后自动生成）
儿子无法继承父亲的构造器——你老子还是你老子
- 解决方法：啃老啃到底——在构造方法里super(field);
- 也可以自己写——儿子出息了
final——断子绝孙
- 修饰符
- 无法继承
- 方法final，无法被重写，只能用爸爸准备好的
- 需要写死就final，比如一些固定的静态常量
  - 即使在同一个类中也改不动
  - 常量定义需要全大写，单词用下划线隔开（ctrl+shift+u=变大写）
  - 一次定义终生使用
  - eg.
```
// 常量定义，避免后续误操作
private static final String TEXT_COMMUNITY_NAME = "flower";
```

权限修饰符/访问控制修饰符

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N（见下方解释）	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

protected 需要从以下两个点来分析说明：

子类与父类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与父类不在同一包中：那么在子类中，子类实例可以访问其从父类继承而来的 protected 方法，而不能访问父类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

个人理解：protected就是“对自己的家人和邻居好，即使家人去了外地，我们也还是一家人；但邻居搬家搬到别处去了我也管不着了。”

请注意以下方法继承的规则：

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

OOP多态

要有继承关系
本质——“花木兰替父从军”

// 替父从军 向上转型
HuaHu huaHu = new HuaMuLan();
System.out.println(huaHu.name);
System.out.println(huaHu.age);
huaHu.fight();

// 有一天，仗打完了，遇上自己心爱的人,做回自己 向下转型
HuaMuLan huaMuLan = (HuaMuLan)huaHu;
System.out.println(huaMuLan.name);
System.out.println(huaMuLan.age);
huaMuLan.dressing();

上面这段程序的输出：

HuaHu

45

干架！

HuaMuLan

19

化妆！

吕子乔类似 aka.吕小布
多个行为，功能多了

JAR包

直接上Maven Repository
工程下New Directory
右键->add as library
设置-编译器-Annotation-第一行Enable
遇到问题在插件里进官网，找github（版本很重要！）
以后尽量用Maven/Gradle
特殊情况，方法重写
- 比如setAge有年龄限制，再写一遍就好

JVM中的堆栈

堆（heap）

用于存放所有的Java对象

栈（stack）

用于存放基本类型数据和对象的引用

变量的声明与使用

基本类型

boolean
char
byte(-128-127，signed)
short
int
long
float
double

(String不是！！！)

关于内存

声明时，会在栈中分配内存
赋值时，把数据放进内存

对象——【指针】

输出

输出一个对象——包名@地址
如果需要输出对象的属性，就需要在类里——toString()，类上@Override

声明

声明一个对象类型的变量时，会在栈中分配内存
这块内存用来存储一个对象的引用（存的是空间地址）【暂且理解为“指针”】

赋值

new一个对象，会在堆中分配内存来存储对象
将该对象类型变量赋值给另一个变量时，相当于两个变量都引用了这个对象

调用

英文的(.)
先找对象类型
再找对象类型里的成员
引用和对象的关系
- 遥控器——引用
- 电视机——对象

构造函数/构造器

new一个对象相当于【注册账户】
构造函数相当于【注册时填写用户名、密码、邮箱】
setter()相当于【注册后再补充资料】
本质——初始化对象：定义+使用
与类名相同
Java当创建一个类，默认隐藏有一个无参的构造函数
- 自己写了有参的，一定要再写一个无参的
一样可以写很多个类型——重载

静态变量/方法

静态属于类，不属于方法
不依赖对象

要用public

/* 有一个Dogs类 */

// flower小区
public static String community = "flower";

// 狗狗月底都要打针
public static void injection(){
    System.out.println("所有狗狗月底都要打针！");
}

// main()里调用
String str = Dogs.community;
Dogs.injection();

就算没有“用户注册”，我也知道我小区是啥（静态，也就是那些不变的属性）
具有强制性，在最上层
本质——“所有都”

但是这时候存在缺陷，它没被封装起来，有风险啊！！！咋办？

// flower小区
private static String community = "flower";

// getInstance()方法——静态不用this
public static String getCommunityInstance(){
    return community;
}

// main()里调用
String str = Dogs.getCommunityInstance();

static单例模式

设计模式——单例
**只有一个！**eg.太阳，地球…

public class Earth{
    //在类里new好，无论怎么get，都是这块内存
	private static Earth earthInstance = new Earth();
    //无参构造——外部类就无法new了
    private Earth(){
        
    }
    //暴露给外部——获取单个实例
    public static Earth getEarthInstance(){
        return earthInstance;
    }
}

在main()里调试：

Earth earth = Earth.getEarthInstance();
Earth earth2 = Earth.getEarthInstance();
Earth earth3 = Earth.getEarthInstance();
System.out.println("earth = " + earth);
System.out.println("earth2 = " + earth2);
System.out.println("earth3 = " + earth3);

输出结果：

earth = com.microsoft.demo.Earth@74a14482
earth2 = com.microsoft.demo.Earth@74a14482
earth3 = com.microsoft.demo.Earth@74a14482

结论：证明你get再多，也就是那一个对象

内部类

不推荐！！！！
实际工作中并不常用
一个文件里只能有一个public class
会用的是“匿名内部类”
静态内部类只能用静态变量
可以在方法里写个class，并且这个类只能在该方法中有效

抽象与具体

衍生

问题提出
- 最开始的父类Animal没人用咋办？？？
- 写继承类有些方法程序员忘记写继承了咋办？？？（比如老鼠还是“动物叫”）
本质来说，最开始的父类是没有人用的，它是抽象的，抽取了各种动物的共性，实际是没人new它的
抽象出现的目的是为了概括具体的共性

// 将Animal改成抽象类
public abstract class Animal{}

// 下面开始报错
Animal animal = new Animal();

使用

避免忘记，在抽象类中的方法前面加上abstract

// 一定需要被继承实现
public abstract void barking();

只要有抽象方法，类必须抽象；但抽象类不一定有抽象方法
一旦抽象，就无法new了
```
new Animal();// 会报错的！！！
```
当一个类继承一个抽象类，此时，该子类必须重写抽象类的抽象方法

接口（Interface）

当一个抽象类中都是抽象方法，没有必要写抽象类，直接上接口
接口里的方法，都是抽象方法
接口不是继承extends，是implements
抽象类的方法我们叫重写，接口的方法我们叫实现
工作应用：DAO Service

抽象类与接口的区别

抽象类是对具体事物的抽象，针对具体事物【根源】
接口是对它的行为进行抽象，针对行为
抽象类不能new，接口可以new

匿名内部类

举个例子(假设Human是个接口)

// 一般用法：内部类
Human chinese = new Human(){
	
	@Override
	public void eat(){
		System.out.println("吃中国菜！");
	}

};
chinese.eat(); 

// 高端用法：匿名内部类
new Human(){
	
	@Override
	public void eat(){
		System.out.println("吃中国菜！");
	}

}.eat();

所有类的爸爸——Object

包括自己定义的类，默认extends Object
所以toString()、equals()、hashCode()等等可以@Override
推荐好物：Apache的开源IO工具包Commons

codeː̗̀(ꙨꙨ)ː̖́bird

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础学习部分笔记

Java怎么执行的.exe和.class的区别.exe是win系统特有的.class字节码文件是跑在jvm上的特殊的可执行文件，需要jvm优点：跨平台缺点：过于依赖虚拟机模拟执行//假如此时有一个Test.java文件public class Test{ //main函数：程序入口点 public static void main(String[] ar...
复制链接

扫一扫