大家好，我是KookNut39也是Tommy，在CSDN写文，写Java时候我是Tommy，分享一些自己认为在学习过程中比较重要的东西，致力于帮助初学者入门，希望可以帮助你进步。感兴趣的欢迎关注博主，和博主一起学习Java知识。大家还可以去专栏查看之前的文章，希望未来能和大家共同探讨技术。
文章目录
- 1.面向对象是什么?
- 2.Java类
- 1.什么是类
- 2.Java类
- 类的结构
- Java类的格式
- 3.java对象
- 4.类和对象
- 5.类中的变量，方法
- 1.变量分类
- 2.方法分类
- 6.方法重载
- 7.对象与引用
- 基本类型和引用类型的区别:
- 值传递与引用传递
- 8.static关键字
- 概念
- static属性
- static方法
- 代码块
- 9.类的加载执行
- 10.包
- 包的概念：
- 包的作用：
- 包（package）的命名规范：
- 访问权限修饰符
- 11.面向对象语言的三大特征
- 1.封装
- 2.多态
- 3.继承
- 12.类于类之间的关系
- 1.关联关系(has-a)
- 2.依赖关系(uses-a)
- 3.继承关系（is-a）
面向对象程序设计是当今主流的程序设计范型，它取代了20世纪70年代的“结构化”或过程式编程技术。
——Java核心技术 卷1（11版）
由于Java是面向对象的，所以我们必须熟悉面向对象程序设计才能更好的使用Java
1.面向对象是什么?
面向对象：object oriented programming 缩写 OOP面向对象的编程语言
- 以分类的方式进行思考和解决问题。
- 面向对象先对整体关系作出分类，然后根据不同的类深入细节的处理。
- 面向对象的思想符合人类的认知习惯。
我见过举的最多的例子就是把大象放进冰箱：
面向对象的思想就是把这件事的三个步骤：打开冰箱，放入大象，关闭冰箱。这三个动作俩个是关于冰箱的，一个是关于操作人的。所以就把打开冰箱，关闭冰箱这俩个操作定义在冰箱这个对象中，把放入大象定义在人这个对象中。于面向过程不同的就是在，面向过程关注的是正在发生什么事，面向对象关注的是发生这件事和谁有关系。
面向对象的程序是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。
——Java核心技术 卷1（11版）
注意
面向对象无法取代面向过程，他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时（在类中定义一个方法），仍然采用面向过程的思维方式。
对于一些规模较小的问题，将它分解为过程的开发方式比较理想，面向对象的设计思想适用于规模较大的项目，把很多个过程转换为较少的类，这更便于程序员管理，寻找错误时与比较方便（假设一个数据出现了错误，你只需要找访问这个数据的方法）。
2.Java类
1.什么是类
类是构造对象的模板或蓝图，我们可以将类想象成制作小甜饼的模具，将对象想象为小甜饼。
——Java核心技术 卷1（11版）
也就是说：
- 类就是将一类事物的相同的属性，行为放在一起
- 类是表示一个客观世界某类群体的一些基本特征抽象.
2.Java类
类的结构
变量：事物属性的描述；
方法:事物的行为；（可以做的事情）
构造方法：用于创建对象；(创建类的时候有一个默认的无参的构造方法)
内部类： 即在类体中声明的类。
块：一段没有名称的代码块
Java类的格式
[访问权限修饰符] [修饰符] class Person{
//第一步声明一个类
/*访问修饰符有两种public，无(默认)
修饰符：final,abstract
关键字class用来定义一个类
Java类名的命名规范:
类名首字母大写,见名知意,驼峰表示*/
//第二步给类添加属性
//成员变量定义
/*
[访问权限修饰符] [修饰符] 属性类型 属性名;
*/
public String name; //名字
public Integer age; //年龄
//第二步给类添加方法
/*方法声明格式为:
[访问权限修饰符] [修饰符] 返回值类型 方法名(){
}*/
public void eat(){
System.out.println("吃饭");
}
}
3.java对象
对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例
上面举得例子人就是一个类，我们每个人都是一个对象，拥有类中的属性，行为，可以使用。
对象的创建和使用：
Person person = new Person();
Person person：使用Person类作为类型声明一个变量person（对象变量）。
new Person()：使用new + Person 类构造方法创建对象.
=：将右边创建的对象地址 赋给 左边的person变量
使用person变量可以访问对象中的成员变量和成员方法.
注意：
-
同一类的每个对象有不同的成员变量存储空间。
-
同一类的每个对象共享该类的方法。
要想使用对象，必须清楚对象的三个主要特征：
- 对象的行为：可以对对象完成哪些操作，或者可以对对象应用哪些方法。
- 对象的状态：当调用那些方法时，对象会怎么样。
- 对象的标识：如何区分具有相同行为与状态的不同对象。
4.类和对象
类是一类事物的抽象概念，是一个模型
对象是由这个模型所创造的一个个具体存在的，实实在在存在的实例。
所以创建对象的过程也叫实例化对象。
编程中现有类后有对象。
现实生活中先有对象后有类（相当于根据对象，总结出来的类）。
5.类中的变量，方法
1.变量分类
按照位置分
成员变量：
成员变量是定义在类中，方法体之外的变量。
成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
成员变量在创建对象的时候会从类中复制一份到对象中。
成员变量可以被类中方法、构造方法和特定类的语句块访问。
成员变量的作用范围为整个类体。
局部变量：
在方法、构造方法或者语句块中定义的变量被称为局部变量。
局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。
局部变量在使用前必须初始化赋值。
变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
2.方法分类
成员方法：成员方法是定义在类中。这种方法在创建对象的时候创建。
语法格式：
修饰符 返回值类型 方法名(参数列表) {
方法体语句；
[return 返回值]
}
构造方法：用来创建对象的方法
构造方法名与类名相同,且没有返回值，且不需要使用void修饰。
构造方法是定义在 Java 类中的一个用来创建对象的方法。
使用 new + 构造方法 创建一个新的对象。在创建一个对象的时候，至少要调用一个构造方法。
每个类都有构造方法。如果没有显式地为类定义构造方法，Java将会为该类提供一个默认构造方法，但是只要在一个Java类中定义了一个显示的构造方法后，默认的无参构造方法即失效。
一个类可以有多个构造方法。
public class Person{
public Person(){
}
public Person(String name){
// 这个构造方法有一个参数：name
}
}
例：创建Person类的对象
Person person= new Person();
Person person = new Person("张三")；
6.方法重载
方法的重载是指同一个类中具有相同的名字，但参数不同的几个方法。
参数不同（可以有三方面的不同）
- 数量不同
- 类型不同
- 顺序不同
调用时，会根据不同的参数表选择对应的方法。
注意：方法重载跟方法的返回值类型没有任何关系
7.对象与引用
Java 语言中除基本类型之外的变量类型都称之为引用类型。
Java中的对象是通过引用对其操作的。
class Person{
String name;
String age;
}
Person person= new Person();
创建一个对象包含三个动作:
- 右边的“new Person()”，是以Person类为模板,调用Person类的构造方法,在堆空间里创建一个Person类对象。
- 左边的“Person person”创建了一个Person类型引用变量。所谓Person类的引用，就是以后可以用来指向Person对象的对象引用。
- ”=”操作符使对象引用指向刚创建的那个Person对象。
Person person;//对象引用变量
person= new Person();//对象本身
new Person(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。
对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。
对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。
Person person1; //创建一根绳子，一根还没有系上任何一个气球的绳；
Person person2;//又做了一根绳，还没系上气球，
person1 = new Person();//给person1系上气球；
person2 = person1；//这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。
结果是，person2也指向了person1所指向的对象。两根绳系的是同一只气球。
基本类型和引用类型的区别:
基本类型
byte,short,int,long,float,double,char,boolean
它的值就是一个数字，一个字符或一个布尔值.
引用数据类型
类,接口,数组
它的值是对象在内存空间中的地址,
值传递与引用传递
Java中进行方法调用中传递参数时，参数传递有两种：
- 值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
- 引用传递：(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。
8.static关键字
概念
- static被称为静态，可以用来修饰类的属性,方法,代码块,内部类。
- 随着类的加载而加载
- 优先于对象存在
- 修饰的成员，被所有对象所共享
- 可不创建对象，直接被类调用
static属性
静态属性是类的所有对象共享的，不管创建了多少个对象，静态属性在内存中只有一个。
static方法
可以使用对象调用，也可以直接用类名调用，建议用类名直接调用
在static方法内部只能访问类的static属性，不能访问类的非static属性，因为static属性先加载。
因为在类加载的时候加载方法，非static属性还没有加载，如果在静态方法中访问非static属性，该属性找不到。
代码块
代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块
//实例块：每次创建对象时自动调用
{
//任何符合语法的Java代码
}
//静态块：类加载时自动调用，仅一次，与是否创建对象无关。
static {
//任何符合语法的Java代码
}
9.类的加载执行
创建对象时，先执行静态代码块，在执行实例代码块，然后执行构造方法。
10.包
包的概念：
包就相当于一个文件夹
包的作用：
避免类重名
按照不同功能管理类
控制访问权限
包（package）的命名规范：
在包名中，可以使用 . 号来区分包的级别；包名一般情况下是小写
- 第一级 指该项目的类型，如com等，
- 第二级 指项目所开发或者运行的公司名称，如：oracle,sun,huawei等
- 第三级 指项目的名称。
- 第四级 指项目模块的名称。如：filter等表明这个包下类的功能
包可以更好得管理逻辑相关的类，可以控制不同包之间的访问权限
导入外部包的类，关键字import
访问权限修饰符
Java语言有四个权限访问修饰符，权限从大到小依次为：
- public ：公共权限 修饰类、属性、方法。可以被任意类访问
- protected：受保护的权限 修饰属性、方法。可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
- default：同包权限 修饰类、属性、方法。只能被同包的类访问
- private：私有权限 修饰属性、方法。 只能在本类中访问
11.面向对象语言的三大特征
1.封装
封装：有时称之为数据隐藏，将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
好处：隐藏类的实现细节，方便加入控制语句，方便修改实现
具体表现是
-
属性使用private权限 （私有的）
-
方法使用public权限
例子：
public class Person { private String name; private String age; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } }
我们可以发现上述代码用到了this关键字，那么什么是this关键字呢？
this关键字代表自身类的对象
功能：
- 使用this关键字引用成员变量
- 使用this关键字引用成员方法
注意：this关键字必须放在非静态方法里面
在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。
例如上面的：
this.name = name; //把局部变量赋值给自己类的成员变量
2.多态
多态是同一个行为具有多个不同表现形式或形态的能力
多态的优点
- 消除类型之间的耦合关系
- 可替换性
- 可扩充性
- 接口性
- 灵活性
- 简化性
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象：Parent p = new Child();（Child类继承了Parent 类）
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
public class Test {
public static void main(String[] args) {
show(new Cat());
show(new Dog());
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) {
Cat c = (Cat)a; //向下转型
c.work();
} else if (a instanceof Dog) {
Dog c = (Dog)a;
c.work();
}
}
}
public abstract class Animal {
abstract void eat();
}
public class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
public class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
Test中的main方法输出：
同一个方法在不同情况下的表现不同，就是多态的体现。
3.继承
继承：继承是面向对象程序设计不可缺少的设计思想，是实现代码可重用的根基，是提高代码可扩展性的主要途径。
继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。
- 在JAVA中使用extends关键字来表示继承关系。
- JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。
- 继承之后子类可以调用父类的所有非私有属性和非私有方法。
什么时候使用继承呢？
当你想用一些非本类的方法或属性时，可以使用继承，继承想使用的那个类，就可以将那个类中的属性方法拿过来用，可以让你少写一些代码。所以继承是代码重用的一种方式
public class Animal{
public static void eat(){
System.out.println("动物吃");
}
}
public class Dog extends Animal{
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
}
}
专业术语：
Dog类是 Animal类的子类, Animal类是Dog类的父类（或者是） Dog类是 Animal类的派生类, Animal类是Dog类的基类。
继承的传递性
C类从B类继承,B类又从A类继承
那么C类就具有B类和A类的所有非私有的属性和方法
当一个没有继承任何一个类时，jvm（java虚拟机）会默认让类继承Object类
Object是 java为所有类提供的基类
继承中的构造方法
子类构造方法总是先调用父类构造方法，默认情况下，调用父类无参构造方法
可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法
如果用super，必须写在方法的第一行
如果子类的构造方法中没有显式地（使用super）调用基类构造方法，则系统默认调用基类无参数的构造方法。
为什么要先创建父类：子类创建后需要调用父类的方法,所以在创建子类对象是父类也需要同时被创建.
我们又提到了一个新的关键字——super
super关键字用途
-
super关键字代表父类的引用，在程序中主要的用途
-
在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行。
-
用“super.成员变量名”来引用父类成员变量。
-
用“super.方法名（参数列表）”的方式访问父类的方法。
-
与this的区别，this通常指代当前对象，super通常指代父类。
方法的重写(OverRide)
在子类中可以根据需要对从基类中继承来的方法进行重写。
方法重写规则
- 方法名相同、参数列表相同；
- 返回值类型相同；
- 访问权限等于或大于父类中方法权限;
只有方法体不同（大括弧内的代码不同）
注意：构造方法不能重写
应用场景：
当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)
12.类于类之间的关系
1.关联关系(has-a)
对象和对象之间的连接。在Java中，关联关系的代码表现形式为一个类做为另一个类的属性类型存在。
就是相当于我们在我们的类中定义了一个String类型的属性，那么，我们这个类和String类就是关联关系。
即“有”的关系：”has-a”。
关联关系分为单向关联和双向关联
- 单向关联： A类关联B类。
- 双向关联：A类关联B类,B类关联A类;
public class Phone {
private Person per;//手机有主人
}
public class Person {
private Phone phone;//人拥有手机
}
关联关系的多重性
一对一关联：一个手机只能有一个主人
一对多关联：一个人，可以拥有多个手机。
解决一对多的关联的方案：集合或者数组
public List<Phone> phoneList;//集合
public Phone[] phones;//数组
2.依赖关系(uses-a)
依赖关系是指一个类A使用到了另一个类B，也就是说一个类的方法使用或者操作另一个类的对象
依赖关系的特性：
这种关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。
依赖具体表现
- 在代码层面，依赖关系表现为类B作为参数被类A在某个方法中使用
例：
public class Person {
public void travel(Bus bus){}
}
注意：
应该尽量减少类与类之间有这种关系
3.继承关系（is-a）
这种关系在上文中有过解释，在这就不赘述了，写在这只是表明类与类还有这种关系。
本次的分享到这里就结束了，码字不易，如果喜欢，赏个点赞+评论+收藏🤞🤞🤞，感谢您的支持
文中举例，用词等可能有不当的地方，望谅解，欢迎在评论区批评指正！
参考书籍：Java核心技术 卷1（11版）
