在这里，我们将给大家分享关于我的Java学习笔记-Java面向对象的知识，让您更了解java面向对象菜鸟教程的本质，同时也会涉及到如何更有效地1.1（java学习笔记）面向过程与面向对象、1.4（ja
在这里，我们将给大家分享关于我的Java学习笔记-Java面向对象的知识，让您更了解java面向对象菜鸟教程的本质，同时也会涉及到如何更有效地1.1（java 学习笔记） 面向过程与面向对象、1.4（java学习笔记） 面向对象内存分析、JAVA OOP学习笔记——面向过程与面向对象、java 基础学习笔记 第二周 (面向对象)的内容。
本文目录一览：- 我的Java学习笔记-Java面向对象（java面向对象菜鸟教程）
- 1.1（java 学习笔记） 面向过程与面向对象
- 1.4（java学习笔记） 面向对象内存分析
- JAVA OOP学习笔记——面向过程与面向对象
- java 基础学习笔记 第二周 (面向对象)
我的Java学习笔记-Java面向对象（java面向对象菜鸟教程）
今天来学习Java的面向对象特性，由于与C#的面向对象类似，不需详细学习
一、Java继承
继承可以使用 extends 和 implements 这两个关键字来实现继承。
extends：类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}implements：使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}* C#的继承：C# 不支持多重继承。但是，可以使用接口来实现多重继承。C#的继承使用冒号（：）
supper与this关键字
supper关键字用来实现对父类成员的访问，用来引用当前对象的父类
this关键字是指向自己的引用
构造器
子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。
二、Java override与overload
Override：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
Overload：重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
三、多态
四、抽象类
五、封装
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
六、接口
七、包（package)
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。
包语句的语法格式为： package pkg1[．pkg2[．pkg3…]];
例如,一个Something.java 文件它的内容
package net.java.util
public class Something{
...
}那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。
import关键字：
为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。
1.1（java 学习笔记） 面向过程与面向对象
面向过程思考时，我们会先思考具体的步骤，第一步走什么，第二步做什么。
比如电脑新建文件夹，第一步：打开电脑
第二步：按下鼠标右键。
第三步：找到新建选项
第四步：点击新建选项下的文件夹
c 语言是典型的面向过程的编程语言，注意步骤即可。
面向过程编程思想，适合于简单的不需要协作的单独部分。
而现实中有很多复杂的事物，用面向过程去思考每一个步骤是不现实，比如如何制作一台电脑。
这种比较复杂的问题用步骤列出来不现实，这时就可以采用面向对象来思考。
采用面向对象的思考方式时思考的是 “电脑是怎么设计的？”
将电脑分解成一个一个对象：
CPU
GPU
主板
内存
等对象。
为了便与协作再去找专门做 CPU 的工厂按做 CPU 的步骤（面向过程）去完成，专门做 GPU 的工厂按做 GPU 的步骤去完成。
面向对象从宏观上把握整体的结构，每一个单一的结构又由面向过程来完成。
两者之间是相辅相成的。
初学 java 有些概念不是很清楚，可能理解有偏差。不对之处还望各位指出，共同学习，共同进步。
1.4（java学习笔记） 面向对象内存分析
首先介绍几个概念
栈：
1.栈是方法执行的内存模型，每调用一个方法都会创建一个栈帧。
2.jvm为每个线程创建一个栈，存放方法相关信息，栈属于线程私有不共享。
3.栈由系统自动分配，是连续的内存空间，速度快。
4.栈的特点是先进后出。
堆：
1.堆用于存放创建好的对象。
2.jvm只有一个堆被所有线程共享
3.堆是不连续的内存空间，但由于不连续分配灵活。
静态区：
1.静态区只有一个被所有线程共享。
2.静态区其实也是堆，用来存放常量，类等不变的信息。
以下列代码为例：
有些部分忽略了，只是简述下过程，理解错误之处还望指出。
1 public class Student { //首先构造了一个学生类，里面包含一些基本信息（姓名，学生所使用电脑信息）
2 String name;
3 Computer user_computer;
4
5 void study(){ //还有学生学习(学习的方法中又包含一个电脑的对象)和玩耍的方法
6 System.out.println("我在学习" + user_computer.brand);
7 }
8 void play(){
9 System.out.println("我在玩耍");
10 }
11
12 public static void main(String[] args){
13 Student stu_huangChangfan = new Student();//首先根据学生类这个模板创建一个具体的对象
//huangChangfan这个对象中包含姓名，使用电脑品牌基本属性
14 Computer comput = new Computer(); //以及玩耍和学习的方法(学习方法中又包含一个电脑对象)
//这时需要创建一个电脑对象，并对其赋值。
15 comput.brand = "联想"; //对新建的对象赋值
16 stu_huangChangfan.user_computer = comput; //电脑对象有了具体的信息后赋给学生对象中的电脑对象。
17 stu_huangChangfan.study(); //调用学生对象中方法。
18 stu_huangChangfan.play();
19 }
20 }
21
22 class Computer{ //电脑类，其中包含电脑品牌等信息。
23 String brand;
24 }
下面用一个自己做的小视频结合代码理解。
JAVA OOP学习笔记——面向过程与面向对象
面向过程重在怎么干，怎么按步骤把任务做完；而面向对象重在让谁去干，不关注完成任务的过程与方法。
两者可通过企业发展来类比：
早期的编程任务较简单，所需完成的任务是一些计算方面的工作，这时以面向过程的方式来一步步编写程序是可行的。面向过程适合于这种简单的任务。
企业初期，公司较小，业务也较少，几个人便可流程一步步完成任务 。
代码模拟:
public class Boss{
public 结果 call1 人事部(待执行任务){
人事部类对象.处理方法(待执行任务); //通知人事部去做指定任务
}
public 结果 call2 财政部(待执行任务){
财政部类对象.处理方法(待执行任务);
}
public 结果 call3 行政部(待执行任务){
行政部类对象.处理方法(待执行任务);
}
private 人事部类对象;
private 财政部类对象;
private 行政部类对象;
}另外，面向对象和面向过程关系是很密切的，面向对象编程中包含面向过程，在把复杂问题化为简单方法时，方法的编写就是通过面向过程思想来实现的。
一个经典的比喻：面向对象是盖浇饭、面向过程是蛋炒饭。盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是“可维护性”比较好，“饭” 和“菜”的耦合度比较低。
总结
1.对象说白了也是一种数据结构(对数据的管理模式)，将数据和数据的行为放到了一起。
2.在内存上，对象就是一个内存块，存放了相关的数据集合。
3.对象的本质就一种数据的组织方式。
java 基础学习笔记 第二周 (面向对象)
Day01
什么是抽象数据类型：将不同数据类型的集合组成的一个整体，我们称为抽象数据类型
类就是一个抽象数据类型
成员变量：类中的数据类型就是成员变量（属性）
方法：类中的一些行为就是方法
面向过程（的缺点）：1. 对数据缺乏封装 2. 数据和方法没有隔离
引用变量的赋值：
引用类型存储的的是对象的地址信息，相同类型引用变量之间也可以相互赋值；
引用类型变量之间的赋值不会创建新的对象，但可能会使两个以上的引用指向同一个对象
Emp e1=new Emp();
Emp e2=e1;// 将 e1 的值赋给 e2，他们指向了相同的对象。
也可以将 null（空值）赋给引用变量：Emp e1=null；
DAY02
一个.java 文件中只能有一个 public 类；public 类必须是.java 的类名
例如：文件名为 Example 则有 public class Double_Array02 {
public static void main(String[] args) {...}}
1：方法的签名
1) 方法名 + 参数列表就叫方法的签名
2) 在同一个类中，不允许出现签名相同的两个方法
2：方法的重载
1）方法名相同，参数列表不同，我们称为方法的重载。(重载发生在一个类中，重写发生在子父类中)
3：构造方法
1）在类中定义
2）构造方法名必须与类名相同
3）构造方法没有返回值，也不写 void
class Aoo{
public Aoo(){
}
}
4）一个类若没有写构造方法，则默认有一个无参的构造方法 ;
但是我们若自己写了构造方法，就没有默认构造方法
5）构造方法可以重载
6）this 指代当前对象（往往指向是该对象的成员变量）
7）一个构造方法可以通过 this（）关键字来调用其它的构造方法
DAY03
Java 虚拟机中的内存分配
jvm 中：
会开辟一个称为堆的存储空间，用于存放 new 关键字创建的对象；
会开辟一个名为栈的存贮空间，用于存放程序运行时方法中声明的所有局部变量
方法区用于存放类的信息（Java 程序运行时，首先会通过类装载器载入文件的字节码信息，经过解析后将其装入方法区，类的各种信息（包括方法）都存放在方法区）。
成员变量的生命周期:
可以理解为对象的生命周期，即 new 创建对象时，成员变量生命周期开始，当对象没有地址指向时，对象视为废弃对象，成员变量也被废弃，生命周期结束。
注意：方法只有一份。
成员变量：
存在与类内方法外的变量称为成员变量。
有默认值
存在于堆
局部变量：
存在方法内的变量称为局部变量。
没有默认值
存在于栈
局部变量的生命周期：
方法调用时开始，JVM 会为方法分配一个空间，即栈帧。局部存在栈帧中。
方法调用完毕，栈帧消失，局部变量失效，生命周期结束。
父类的引用可以指向子类的对象，即向上造型 ;
通过父类的引用只能调用父类的成员变量和方法，不能调用子类特有的成员变量和方法 ;
例如：
class Animal{
public void jump(){
}
}
class Tiger extends Animal{
public void eat(){
}
}
public class A{
public static void main(String[] args) {
Animal a=new Animal();
Tiger t=new Tiger();
Animal at=new Tiger(); // 这里创建的对象不能引用子类特有的方法和成员变量
}
}
对于一个父类的引用类型，可以指向该类的对象也可以指向其任意一个子类的对象。
如果需要把父类类型，转换成子类类型，那么需要强制类型转换. 其格式为： 目标类型 变量名 =（）值；
如果父类类型不是指向需要强制类型转换的子类的对象，那么强制转
换会产生造型异常（ClassCastException）
例题：
Cat cat =null;
Animal animal = new Dog();
if (animal instanceof Cat) {
cat = (Cat) animal;
System.out.println(cat.noise());
}else{
System.out.println("animal is not Cat''s instance");
}
其中，animal 指向 Dog 的实例，而不是 Cat 的实例，故代码 “ animal instanceof Cat” 返回 false，程序执
行 else 分支，输出：“animal is not Cat''s instance”。
DAY04
关于构造方法与 super 关键字
子类的构造方法可以通过 super () 来调用父类的构造方法，其往往用来初始化成员变量。
super () 可以不写，默认第一行就有。
super () 必须在第一行
final 关键字
final 修饰变量赋值后不能修改
final: 修饰成员变量。要么声明的同时初始化，要么在构造方法中初始化。
修饰局部变量：在使用之前初始化即可。
final 修饰方法，该方法不能被重写
final 修饰类，该类不能被继承
方法的重写：在父子类中，方法签名相同，方法体不同。我们称之为方法的重写。
无论是父类的引用还是子类的引用，调用的都是重写后的方法.
在重写的方法中，我们可以会用 super 调用父类的方法 (往往是被重写的方法)
子父类继承重写方法中两同两小一大问题：
两同：方法名和参数列表相同
两小：1）返回值类型要小于等于被重写的方法 (基本类型和 void 保持不变)
2）抛出的异常小于等于被重写的方法
一大：重写的修饰符要大于等于被重写的方法的修饰符访问控制符大小问题：
修饰符 本类 同一个包中的类 子类 其他类
public 可以访问 可以访问 可以访问 可以访问
p''ro''tected 可以访问 可以访问 可以访问 不能访问
默认 可以访问 可以访问 不能访问 不能访问
private 可以访问 不能访问 不能访问 不能访问
重载与重写的区别：
重载：在同一个类中，方法名相同，参数列表不同。
调用方法根据参数个数和类型选择调用那个方法
重写：发生在父子类中，方法签名相同，方法体不同。
不管是父类的引用，还是子类的引用，最终调用的都是重写后的方法
调用哪个方法重载看引用类型，重写看对象类型。
static 关键字
static: 修饰的成员变量不属于对象的数据结构，属于类。通过类名. 调用
static 修饰的成员变量存在方法区，并且只有一份。
static: 修饰方法，通常类名. 调用。注意：静态资源不能调用非静态资源
static: 修饰代码块，在类加载时加载一次，只有一份
DAY05
抽象
抽象方法：由 abstract 修饰的方法为抽象方法，抽象方法只有方法的定义，没有方法的实现（实现即方法体，大括号中的部分）, 并以分号结束。
抽象类：由 abstract 修饰的类为抽象类。包含抽象方法的类一定是抽象类；抽象类不一定包含抽象方法。
一个类继承了抽象类，必须要重写父类的所有抽象方法。若不重写抽象方法也可，要把类变成抽象类
抽象类不能被实例化，无论有没有抽象方法。
abstract 和 final 不能同时作用于一个类
final 修饰的方法不能被重写，修饰的类不能被继承。
abstract 修饰的方法要被重写才有意义。
接口
接口：由 interface 修饰的类为接口，接口中的所有方法都必须是抽象方法。但是可以没有任何方法
接口中没有构造方法
接口中不能定义成员变量，但是可以定义常量。往往用 static final 来修饰常量
接口中的方法往往省略 public abstract
implements：实现接口，重写接口中的所有抽象方法。注意：子类重写抽象方法时，控制访问修饰符一定时 public
一个类可以实现多个接口，中间用逗号隔开。
* class&class -->extends
* class&interface -->more implements
* interface&interface -->extends
* class&abstract -->extends
* abstract&abstract -->extend
关于我的Java学习笔记-Java面向对象和java面向对象菜鸟教程的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于1.1（java 学习笔记） 面向过程与面向对象、1.4（java学习笔记） 面向对象内存分析、JAVA OOP学习笔记——面向过程与面向对象、java 基础学习笔记 第二周 (面向对象)等相关内容，可以在本站寻找。
本文标签：
