标签：并且 维护 赋值 对象 成员内部类 问控制 假设 需要 不用
面向对象一些相关概念：
方法的定义：
e.g 修饰符 返回值类型 方法名（） ：public Sting sayHello（参数类型 参数名...）{}；
方法的调用：
方法的调用有：
静态方法和非静态方法
静态方法是加了static的
两者比较：
方法调用中需要注意的点：
构造器详解：
创建对象内存分析：
堆存储对象和系统元素（new的数组或对象），栈存储系统调用变量，存放基本 变量类型和引用变量（例如引用）
自我理解： 栈最底部是存放的main方法，假如你在main方法中new一个对象，程序在加载到此处时，就会加载对应的类，将其放到方法区中，jdk1.7之前，方法区是在堆中的。之后是在内存中的。你new出来的一个对象，其对象名就是引用变量名，放在栈中，指向你存放在堆中的对象。引用变量名就相当于一个容器，存放你new出来的对象的地址。假设有赋值语句，堆中的对象会调用方法区中的方法，对相应变量进行赋值操作。
简单总结：
1.类与对象
类：就是一个抽象的模板 对象：是一个具体的实例
以类的方式组织代码，以对象的方式封装数据
2.方法的定义与调用
调用方面，如果你在一个类中定义的方法是静态方法（static）那么你在main方法中可以直接通过类.方法名来直接调用。如果你定义的是非静态方法，那么你在main方法中就必须先实例化，new一个对象，通过对象.方法名来调用。
3.对应的引用
java中的基本类型有8种：byte、short、int、float、long、double、boolean、char
除基本类型外其他都是引用类型
对象是通过引用来操作的：栈->堆
对象类型 对象名 =对象值
new出来的对象是存放在堆中的，而栈中存放是的对象名也就是引用变量名。该变量名相当于一个容器，存放的是堆中对象的地址，即引用变量名指向所存放的对象 具体操作还是通过堆来实现。
4.属性 也叫字段（field）或者成员变量
类中除了属性就是方法
相关默认初始化
char：u000
boolean：false
引用：null
5.对象的创建和使用
必须使用new 关键词创建对象 构造器 e.g Person ghost =new Person（）；
对象的属性：ghost.name
对象的方法：ghost.shout（）
封装详解：
1.程序设计中讲究“高内聚、低耦合” 高内聚指的是类里面的内部数据操作细节由自己实现，不要让外部干涉，低耦合指的是仅暴露少量的方法给外部使用。 举个例子：一个银行，它里面的一些重要数据，是通过银行内部人员自己操作完成，这是高内聚的体现。而用户则围绕一张银行卡实现取钱存款的操作。即低耦合的表现。
2.封装即数据的隐藏。实际上应该通过相应的操作接口，即定义相关方法来访问类中的属性。而应该禁止直接访问一个对象中数据的实际表示。此为信息的隐藏 举个例子：你定义了一个学生类，类中定义了姓名等相关属性，你在main方法中通过实例化了一个对象，通过对象名.属性对其学生类中的属性进行直接访问赋值。实际上不应该这样，应该时学生类中的属性私有，设置相关方法对属性进行操作。然后实例化对象后，通过对象名.方法间接操作类中的属性。
3.总结来说就是这几个关键词：属性私有， get/set 注：set方法里面有时候会设置一些安全性的判断。
封装的意义：
1.提高了程序的安全性，保护数据
2.统一了接口，提高了系统的可维护性
3.隐藏了代码的实现细节
继承的知识点
1.继承是对一批类的抽象，继承有利于我们实现对现实世界的建模
2.继承描述的是类与类之间的关系
3.继承的关系，一个是子类（派生类），一个是父类(基类），子类继承父类，使用关键词extends来表示 e.g public class Student extends Person
4.子类与父类之间的关系应该具有“is a“的关系 比如子类教师类，父类人类 教师is a 人。
5.在java中，所有类都默然直接或间接继承Object类
6.java中类只有单继承，没有多继承。
public->protected->default->private 优先级从左至右依次递减
讨论子类与父类中this和super：
在子类中，如果定义了一个方法，在方法中可以通过this.属性访问自己类中定义的属性，通过super.属性访问父类中定义的属性。也可以通过this.方法名调用自己类中的方法，通过super.方法名调用父类的方法
this和super代表的对象不同
this：本身调用者这个对象
super：代表父类对象的应用
前提：
this：没有继承也能使用
super：只能在继承条件下使用
关于构造方法this（）和super（）；
this（）:表示本类的构造 super（）：表示父类的构造
子类继承父类，在子类的无参构造中，第一句会是隐藏的代码super（）；即在new出来一个对象后，实际上也就是调用构造方法，会先调用子类中父类的无参构造，再调用本类。
关于super（）：
1.super（）在调用父类的构造方法，必须在构造方法中的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
方法的重写知识点：
定义两个类，一个A类，一个B类。A类为子类，B类为父类。
在两个类中创建了个方法名相同的静态方法。
在main函数中，new两个相同对象，但是对象类型不同，一个是A 一个是B。e.g A a=new A（）； B b=new A（）；
使用对象名.方法名调用方法
对于静态方法来说，方法的调用只和左边定义的数据类型有关。因为静态方法是在类加载时就一起加载了。
但是如果定义的是非静态方法，同样采用以上的步骤，则是不同的结果。此为方法的重写。即子类重写了父类的方法，输出的结果即是子类的。
关于方法重载和重写：
重写
1.方法名和参数列表必须相同，方法体不同
2.方法的重写需要有继承关系，子类重写父类的方法
3.修饰符：范围可以扩大但不能缩小。 private->default->protected->public
4.抛出的异常：范围可以被缩小但是不能被扩大
为什么要重写：
1.父类的功能，子类不一定需要或者不一定满足
重载
1.方法名相同，参数列表不同
关于多态
1.多态的定义是同一种方法可以根据发送对象的不同采用多种不同的行为方式
2.多态是方法的多态，属性没有多态性。
3.一个对象的实际类型是确定的，但是引用类型可以不同。
e.g
创建两个类，一个父类Person，一个子类Student。子类继承父类
实际类型例如，new Student（）；你new出来的对象都是确定的。
引用类型例如： Student s1=new Student（）；
Person s2=new Student（）；可以看出引用类型不同， 第二种是父类的引用指向了子类的对象。
4.对象能执行什么方法，主要看对象左边的类型；
如上 创建的两个对象，一个类型是Person，一个类型是Student；
（1）对于Student类型，它能执行的方法除了自己的还有继承过来的方法；
（2）对于Person类型，可以执行子类，但是不能调用子类的方法；
（3）如果使用引用类型是父类的对象调用方法，假如子类中有和父类一样的方法（即方法的重写）则会调用子类的方法 / /即子类重写了父类的方法，执行子类的方法
5.多态存在的条件：有继承关系、子类重写父类的方法、父类的引用指向子类的对象。
6.子类转换为父类为向上转型 可能会丢失方法
7.父类转换为子类需要强制转换，为向下转型
8.这种转换方便了方法的调用， 就是不用重新再去NEW一个对象。直接类型转换再调用方法。
关于static关键字的相关知识点：
1.在创建的类中对声明的变量加入修饰符static，表示这是个类变量（静态变量）。类变量在main方法中可以通过（类名.变量名）或者实例化一个对象，通过（对象名.变量名）的方法调用，但是最好使用第一种，直接表明了这是个类变量。 而如果声明普通的变量（实例变量）。则需实例化一个对象，通过（对象名.变量名）的方法调用。
2.同样的，在方法中使用static关键词修饰符，与上述情况描述相同。
3.在创建的类中，有不表示的匿名代码块和静态代码块和构造方法。
main方法中new一个对象，静态代码块首先执行，然后再是匿名代码块，之后再是构造方法。匿名代码块可以用来赋初始值，而静态代码块只执行一次。
关于静态导入包；
一般我们导入工具类，在main方法可以直接通过工具类名.方法名调用里面的方法。但是如果你不想通过类名。想直接通过方法名。可以直接通过静态导入包。
e.g：
关于抽象类：
1.抽象类就是在类的前面加关键词abtract
2.抽象方法，只有方法名，没有方法体，也就是没有方法实现。
3.如果一个抽象类里面有抽象方法，则该抽象方法必须由其继承的子类实现。也就是说子类必须重写父类（抽象类）的方法。
4.抽象类不能new对象，只能靠子类去实现它。
5.抽象方法必须在抽象类中，抽象类中可以有普通方法
关于接口：
1.接口本质就是一种契约，一种约束。定义的是一组规则。声明接口通过关键字interface定义。
2.接口中定义的所有方法都必须是抽象的 public abstract；
3.接口中定义的变量是全局静态常量 public static final；
4.接口是一种约束，可以通过子类实现。通过关键字implement继承接口。实现接口，就必须重写接口中的方法。
5.接口可以实现多个
6.接口不能被实例化，它没有构造方法。
接口和抽象类的区别：
1.抽象类是通过（类 extends 抽象类）单继承，而接口可以多继承
2.抽象类中可以有普通方法，抽象方法必须在抽象类中，并且抽象方法没有方法体。而接口中定义的方法都必须是抽象的。
3.子类实现抽象类和接口都必须重写其里面对应的抽象方法。
关于N种内部类：
1.成员内部类：就比如你定义一个A类，然后在A类的内部再定义一个B类，B类就是成员内部类，B类可以使用任意访问修饰符，它可以访问外部类中的属性。
定义了成员内部类之后必须使用外部类对象来创建内部类对象：e.g
如果外部类和内部类具有相同的成员变量或方法，内部类可以直接访问内部类的成员变量或方法，但如果内部类访问外部类的成员变量或者方法时，需要使用this关键字；
外部类名.this.属性名（方法名）
2.方法内部类，就是在定义在外部类方法中的类。方法内部类只能在该方法内使用，不同使用访问控制符和static关键词
3.静态内部类：就是在外部类内加了static关键词的内部类
静态内部类不能访问外部类的非静态成员，但是可以通过new.外部类（）.属性名访问。
如果外部类有静态成员，则可以通过直接调用的的方法访问外部类的静态成员，但是如果内部类中有和外部类同名的静态成员，静态内部类访问外部类的静态成员时，需要通过外部类名.属性名访问。
创建静态内部类的对象可以直接创建。
**一个java文件中可以有多个class类，但是只能有一个public class类。
标签：并且 维护 赋值 对象 成员内部类 问控制 假设 需要 不用
原文地址：https://www.cnblogs.com/theghost/p/13706437.html
