java学习笔记
Posted q1427094386
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java学习笔记相关的知识，希望对你有一定的参考价值。
java笔记
一、面向对象
1、面向对象
面向对象简称 OO（Object Oriented）也称面向对象思想。 它是一种编程思维，也是一种思考问题的方式。
基本思想是面向对象的三大特征 继承，封装，多态 进行程序设置。
2、累和对象
类： 是对象的抽象！对象 是类的具体！
类： 是对具体有相同特征或属性，具有相同行为能力的一类具体事物的描述或称呼。
对象： 是这一类事物带有属性值，具有具体行为的个体或者实例。
3、类的定义和使用
按照驼峰结构 如果是变量每个单词首字母要小写 如果是类名每个单词首字母都要大写
在Java中定义一个类使用class关键字，一个合法的标识符和一对表示程序体的大括号。
语法如下：
[访问修饰符] class <classname>{ --class关键字 --classname 一个合法的标识符
<body of the class>
}
class 是创建类所使用的关键字
<classname> 代表类的名称， 简称类名，是写规范参考 [阿里巴巴Java开发手册]
<body of the class> 包含属性和方法
类的属性（特征）有什么？
//汽车有什么----》叫类的属性
//品牌
private String brand;
//名称
private String name;
//颜色
private String color;
//车架号
private String vin;
总结：
类定义中的属性使用具体的数据类型及名称来进行描述，属性描述的是这个类所代表的所有具体的对象都有些什么，也就是这个类的属性
那方法呢？
类的方法（行为）能干什么？
//汽车能干什么？
public void canRun(){
System.out.println("汽车能跑！");
}
总结：
类中的方法描述的是这个类所代表的的所有具体的对象能干什么，也就是这个类的行为（方法）。
类是怎么使用的？
类的定义是对某一事物的描述，是一种抽象，想要使用类，需要生成该类的对象。
怎么生成对象，可以使用new关键字，new关键字可以创建对象
Car car = new Car();
怎么使用刚才创建的对象？ --也就是怎么访问属性跟方法
public class Car {
//汽车有什么？ ----叫类的属性
//品牌
private String brand;
//名称
private String name;
//颜色
private String color;
//车架号
private String vin;
//汽车能干什么？ ---方法
public void canRun(){
System.out.println("汽车能跑！");
}
public static void main(String[] args) {
//1、创建对象 new
Car car=new Car();
//2、怎么使用属性
//2.1、 给属性设置值
car.brand="特斯拉";
car.name="Model3";
car.color="银色";
car.vin="13525738475";
//2.2、获取属性值
System.out.println(car.brand);
System.out.println(car.name);
System.out.println(car.color);
System.out.println(car.vin);
//3、怎么调用方法
car.canRun();
}
属性的默认值、如果不给属性设置值那么获取的属性就是null
| 属性 | 默认值 |
|---|---|
| byte | 0 |
| char | char 的默认值为 空字符 |
| short | 0 |
| int | 0 |
| long | 0 |
| float | 0.0 |
| double | 0.0 |
| boolean | false |
| String | null |
4、构造方法
构造方法 定义：
对于构造方法来说，没有返回值这一说法
构造方法： 是一种特殊的方法，用来创建对象，分为无参构造方法以及有参构造方法
无参的构造方法
每个类中都有一个磨人的无参的构造方法，也就是不需要我们写就可以直接使用
Car car=new Car();
有参的构造方法
如果我们定义了一个带参数的构造方法，系统则不再提供磨人的无参的构造方法
public Car(String name){
this.name=name;
}
错误的写法，使用了有参的构造方法的话，在使用默认的无参构造方法 就会报错
Car car=new Car("ModelX");
Car car=new Car(); --此时就会报错；没办法这样写
解决
1.因为他不认识
Car car=new Car(); 方法
2.在新建一个无参的构造方法
public Car(){
}
5、 this关键字
在有参数的构造方法中使用
this 关键字是当前对象的引用
public Car （String name）{
this.name=name；
}
this关键字一般用在构造方法里面
6、方法重载
定义： 一个类中如果有多个同名方法（方法名相同），但是参数个数或参数类型不同，那么这就叫做方法的重载
方法的重载的目的是： 功能类似的方法使用同一名字，更容易记住，因此调用起来更容易，更简单。
注意： 方法重载的返回值类型通常都是相同的，也就是说返回值不作为重载的判断依据
7、static 关键字
有两方面作用
static 修饰的变量
静态变量，可以通过类名直接进行访问
static 修饰的方法
静态方法，可以 通过类名直接调用
区别：
在普通方法 中能不能使用 普通属性 静态变量 普通方法 静态方法 ok
在静态方法 中能不能使用 普通属性 (×) 静态变量（√） 普通方法 (×) 静态方法（√）
在main方法中 访问
//先声明
// 普通的成员变量
int a;
// 静态的成员变量
static int b;
// 普通的方法
public void ceshifangfa() {
System.out.println("测试普通方法");
}
// 静态的方法
public static void ceshijingtaifangfa() {
System.out.println("测试静态方法");
}
在main方法中 访问
public static void main(String[] args) {
//普通变量
//1. 先创建一个对象 这时会调用一个默认的无参的构造方法
StaticDemo staticDemo = new StaticDemo();
//2. 输出一下 对象 . 变量名称 staticDemo.a
System.out.println(staticDemo.a);
// 静态变量怎么访问
// 1. 直接使用 类名.定义的变量名称
staticDemo.b=5;
System.out.println(staticDemo.b);
// 普通方法怎么访问
// 1. 用 对象名 . 方法名
staticDemo.ceshifangfa();
// 静态方法怎么访问
// 1. 用 类名 . 方法名
StaticDemo.ceshijingtaifangfa();
}
在普通方法中
// 普通的方法
public void ceshifangfa() {
// 普通的变量
System.out.println(a);
// 静态的变量
System.out.println(b);
// 普通的方法
text();
// 静态的方法
ceshijingtaifangfa();
System.out.println("测试普通方法");
}
在静态方法中
public static void main(String[] args) {
//普通的变量
System.out.println(a); // 报错 飘红
//静态的变量
System.out.println(b);
//普通的方法
text(); // 报错 飘红
ceshifangfa();
//静态的方法
ceshijingtaifangfa();
}
package static_text;
public class StaticDemo {
// 普通的成员变量
int a;
// 静态的成员变量
static int b;
// 普通的方法
public void ceshifangfa() {
// 普通的变量
System.out.println(a);
// 静态的变量
System.out.println(b);
// 普通的方法
text();
// 静态的方法
ceshijingtaifangfa();
System.out.println("测试普通方法");
}
// 普通方法2
public void text() {
System.out.println("普通方法2");
}
// 静态的方法
public static void ceshijingtaifangfa() {
System.out.println("测试静态方法");
}
public static void main(String[] args) {
// 普通的成员变量怎么访问----属性的访问
// 1. 先创建一个对象 这时会调用一个默认的无参的构造方法
// 2. 输出一下 对象 . 变量名称 staticDemo.a
StaticDemo staticDemo = new StaticDemo();
// staticDemo.a=10;
// System.out.println(staticDemo.a);
// 静态变量怎么访问
// 1. 直接使用 类名.定义的变量名称
// staticDemo.b=5;
// System.out.println(staticDemo.b);
// 普通方法怎么访问
// 1. 用 对象名 . 方法名
staticDemo.ceshifangfa();
// 静态方法怎么访问
// 1. 用 类名 . 方法名
// StaticDemo.ceshijingtaifangfa();
// 区别
// 普通方法中能不能使用 普通属性 静态变量 普通方法 静态方法 ok
// 在静态方法中能不能使用 普通属性 (×) 静态变量（√） 普通方法 (×) 静态方法 （√）
// //普通的变量
// System.out.println(a);
//
// //静态的变量
// System.out.println(b);
//
// //普通的方法
// text();
// ceshifangfa();
//
// //静态的方法
// ceshijingtaifangfa();
}
}
二、继承和多态
1、掌握继承的含义以及用法
1.1、什么是继承继承？ extends–继承 关键字。
继承： 是java面向对象编程技术的一块基石，因为他允许创建分等级层次的类。
1.2、继承的概念
继承 就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
1.3、继承的解析
Car（汽车类）和Truck（卡车类）类都具有一些相同的属性和方法，我们将这些共同的属性和方法新建一个类Vehicle（车辆类）类，使得Car和Truck两个类都继承
自Vehicle类,具有Vehicle类的属性和方法。
1.4、继承的作用
继承 是面向对象语言的重要机制。借助继承，可以扩展原有的代码，应用到其他程序中，而不必重新编写这些代码，也就是代码可以复用
1.5、举例
Vehicle（车辆类）类具有基本的属性和方法。
Truck（卡车类）继承自Vehicle（车辆类）则具备父类Vehicle的属性和方法，而我们只需要关心Vehicle所具备的单独的属性或方法。
1.6、继承的格式
[ public ] class 父类{
}
[ public ] class 子类 extends 父类{
}
1.7、继承的类型
java不支持多继承，但是支持多重继承
图解
1.8、继承的特性
- 子类拥有父类非 private的成员属性、成员方法(不继承父类的构造方法
- 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- java的继承是单继承,但是可以多重继承。
- 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。
2、掌握方法的重写
2.1方法的重写（覆蓋）
重写 在继承关系中，子类对从父类继承过来的方法进行改进，变成自己的方法,这种现象就称之为方法的重写或者方法的覆盖。
2.2、重写的要求
- 三同原则：同方法名，同返回类型，同参数表。 方法体可以不一样
- 子类中的覆盖方法不能使用比父类中被覆盖的方法更严格的访问权限。
2.3、方法重载与重写的区别：
- 一个类中的方法，它们满足方法名，参数列表相同，这叫做方法的重载。
- 子类根据需要对从父类中继承来的方法进行重写。
3、理解多态及其应用
3.1、多态的介绍 举例
多态 指的是多种形态。例如,同样是水的成分,但也有液态水及冰的多种形态。同样是二氧化碳,就存在气态及液态等多种形态。同样是猫科动物,就有猫和老虎的区别
3.2、继承的表现就是多态。
一个父类可以有多个子类,而在子类里可以重写父类的方法,每个子类重写的代码又不同,自然表现的形式就不一样。如果用父类的变量去引用不同的子类对象,在调用
相同的方法的时候得到的结果就和表现形式就不一样了,这就是多态。
注意:
还需要注意一点的是,由父类引用创建的对象,只能调用子类从父类继承的方法,而不能调用自己扩展的方法。
4、掌握super关键字
super关键字
super(超类): 用ava术语来讲,被继承的类称为超类,继承的类称为子类。
在某些时候,子类需要调用父类的某些方法,这个时候我们就需要用到 super。
super关键和this作用类似,是被屏蔽的成员变量或者成员方法或变为可见,或者说用来引用被屏蔽的成员变量和成员方法。不过 super是用在子类中,目的是访问
直接父类中被屏蔽的成员,注意是直接父类(就是类之上最近的超类）
5、了解Object类
Object类 是Java中所有类的超类（父类）
- 所有类都默认继承自Obejct类
- 每个类都可以使用Object类的方法
toString() 返回该对象的字符串表示，通常改方法会返回一个“以文本方式表示”的对象的字符串。
hashCode() 返回该对象的哈希码值。
equals() 指示某个其它对象是否于此对象“相等”。
6、掌握final关键字
- flnal 表示最终的，最后的，可以用来修饰类，方法，属性（变量）。
- flnal 修饰的类不能被继承。
- flnal 修饰的方法不能被重写。
- flnal 修饰的属性（变量）不能被改变–就是常量的定义方式。
三、包，抽象类，接口
1、掌握包的使用
1.1、包的含义
Java中的一个package（包）就是一个类库单元，包内包含一组类，他们在单一的名称空间之下被组织到了一起，这个名称空间就是包名。
项目中常见的包名 这种分的结果是 按功能分 按层分的
| 包的名称 | 描述 解释 |
|---|---|
| dao | 它是跟数据库打交道 |
| model | 一般是实体内容 |
| service | 业务层 |
| util | 工具类 |
| test | 测试类 |
1.2、包有什么作用?
- 把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
- 如同文件夹一样,包也采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名予以区别。因此,包可以避免名字冲突。
- 包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
1.3、包的声明
语法结构：
package pkg1 [.pkg2 [.pkg3...] ];
pkg1 pkg2 pkg3 为文件系统中的文件夹名称，并存在上下级目录关系。
包的声明的目的是描述此Java类文件属于那个包或者那个文件目录
包的使用
import pkg1 [.pkg2 [.pkg3...] ].<classname>|*; impor 是引入包中的类来使用的
pkg1 pkg2 pkg3 为文件系统中的文件夹名称，并存在上下级目录关系。
classname 代表所要引入的指定的类。 或者用
* 代表引入次包下的所有的类。
包的使用其实就是在一个Java类中使用其他包的Java类。
2、掌握抽象类
1.1、抽象类的概念
在面向对象的领域一切都是对象,同时所有的对象都是通过类来描述的,但是并不是所有的类都只是来描述对象的。
我们抽象类里面的东西对于这个类的描述不够具体 什么叫不够具体？ 我们没有办法去描述这个东西 。
举例
比如 new Animal(),我们都知道这个是产生一个动物 Animal对象,但是这个Animal具体长成什么样子我们并不知道,它没有一个具体动物的概念,所以他就是一个
抽象类,需要一个具体的动物,如狗、猫来对它进行特定的描述,我们オ知道它长成啥样。
1.2、抽象方法
抽象方法 就是我们没有方法体，没有办法把这个方法具体实现的。
具体的表现
就是我们用 abstract这个关键字，我们在class 前面加上 abstract ，那么这就是抽象类
抽象方法
- 没有方法体
- 有abstract
我们有了抽象方法，那么这个类就一定是抽象类。
1.3、怎么写抽象类
在Java语言中使用abstract 在class 前面加上 abstract 来定义抽象类 同样也可以定义抽象方法。
怎么使用抽象类？
抽象类必须通过其子类才能实例化对象。
1.4、抽象类的注意事项：
- 含有抽象方法的类是抽象类。
- 抽象类中不一定有抽象方法。
- 抽象类不能直接创建对象，必须通过子类实现，所以abstract不能和final一起修饰类。
- abstract不能与static，final并列修饰同一个方法。
3、理解接口的使用
1.1、接口
接口 是比抽象类更抽象的一种结构或者类、通常使用interface 来进行描述。
1.2 、抽象类与接口
| 名称 | abstract class | interface |
|---|---|---|
| 继承 | 只能extends一个class | 可以implements多个interface |
| 字段 | 可以定义实例字段 | 不能定义实例字段 |
| 抽象方法 | 可以定义抽象方法 | 可以定义抽象方法 |
| 非抽象方法 | 可以定义非抽象方法 | 可以定义defau方法 |
4、掌握访问修饰符的使用
访问修饰符：Java中,可以使用访问修饰符来保护对类、变量、方法和构造方法的访问
| 类别 | 访问权限 | 使用对象 |
|---|---|---|
| default(即默认,什么也不写): | 在同一包内可见。 | 类、接口、变量、方法 |
| private: | 在同一类内可见。 | 变量、方法。注意:不能修饰类(外部类） |
| public: | 对所有类可见。 | 类、接口、变量、方法 |
| protected: | 对同一包内的类和所有子类可见。 | 使用对象:变量、方法。注意:不能修饰类(外部类) |
访问修饰符范围
| 关键字 | 同一个类中 | 同一个包中 | 派生类中 | 其他包中 |
|---|---|---|---|---|
| private: | √ | |||
| 默认 | √ | √ | ||
| protected: | √ | √ | √ | |
| public: | √ | √ | √ | √ |
注意
我们一般写内容 都是public 一般写实体类，属性一般都是private 方法一般都是public
四、java中的常用类（一）
一、包装类
1.1、什么是包装类？
Byte，Boolean，Character，Short Integer Long，Float Double， 都是包装类。
1.2、包装类的作用
- Java语言是面向对象的语言，但是Java中的基本数据类型却不是面向对象的。
- 即不能使用Object类提供的一些方法比如 toString()等,也不具备面向对象的一些特征不能参与转型、泛型、反射等过程,
- 同样也不能参与到集合的操作中,所以为了弥补这些缺点,Java提供了包装类。
1.3、包装类有哪些？
| 基本类型 | 包装类型 |
|---|---|
| byte | Byte |
| boolean | Boolean |
| char | Charachte |
| chort | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
1.4、包装类怎么用？
装箱 基本数据类型—>包装类型 此过程被称为 装箱。
拆箱 包装类型—>基本数据类型 此过程被称为 拆箱。
int的包装类Integer
//int Integer
int a=7;
Integer b=new Integer(7); //包装类
Integer c=new Integer("7");
System.out.println(a);
System.out.println(b);
System.out.println(c);
//int 和 Integer 之间的相互转换
//int ---> Integer 装箱操作
int i1=8;
Integer i2=new Integer(i1); //装箱操作
Integer i3=i1; //自动装箱操作
System.out.println("————int ---> Integer 装箱操作");
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
//Integer--->int 拆箱操作
int i4=i2.intValue();//("--Integer--->int 拆箱操作" );
int i5=i2;//自动的拆箱操作
System.out.println("Integer--->int 拆箱操作");
System.out.println(i4);
System.out.println(i5);
byte的包装类Byte
byte b = 3;
Byte b2 = 3;
Byte b3 = new Byte((byte) 3);
Byte b4 = new Byte("3");
System.out.println(b);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
// byte Byte 相互转换
// byte --> Byte 装箱操作
Byte b5 = new Byte((byte) 8);//装箱操作
Byte b6 = (byte) 8;//自动装箱操作
//Byte --> byte 拆箱操作
byte b7 = b5.byteValue();//拆箱操作
byte b8 = b6;//自动拆箱操作
System.out.println(b5);
以上是关于java学习笔记的主要内容，如果未能解决你的问题，请参考以下文章