面向对象的特征（封装、继承）
作者：互联网
面向对象的特征（封装、继承、多态）
static关键字 静态的 修饰符[类级别的]
static是修饰符：可以修饰的内容：及验证
1.可以修饰普通方法
2.可以修饰字段[ 成员字段 ]
3.可以修饰内部类[暂时不了解]
4.不可以修饰外部类
5.不可以修饰局部变量；
6.不可以构造方法
小结： 被static修饰得变成全局共享；只能用类名去调，也可以用对象去调；
没有被static修饰得话只能够用对象去访问。
1.有static修饰的字段应该是字段所在类 类名.字段名 进行访问
public static void main(String[] args) {
Student.name = “王歘歘”;
System.out.println(Student.name);
}
class Student{
static String name;
}
---------- Java ----------------------------------
王歘歘
2.没有static 修饰的字段： 字段所在的类的对象：对象名.字段名 进行访问
public static void main(String[] args) {
Student stu = new Student();
stu.name = “歘歘王”;
System.out.println(stu.name);
}
class Student{String name;
}
---------- Java ----------------------------------
歘歘王
3.注意：非static修饰字段：错误的访问方式
public static void main(String[] args) {
Student.name = “王歘歘”;
System.out.println(Student.name);
}
class Student{
String name;
}
修饰方法：如何使用？
1.有static修饰的方法： 方法所在的 类名.方法名(…);
2.没有static修饰的方法 ： 方法所在的类的对象名.方法名(…);
3 字段：什么时候使用static修饰呢？有什么效果
cpublic static void main(String[] args) {
Student stu1 = new Student();
stu1.name = “小渣渣”;
System.out.println(stu1.name);
Student stu2 = new Student();
stu2.name = “大渣渣”;
System.out.println(stu1.name);//大渣渣
System.out.println(stu2.name);
}
class Student{
static String name;
}
因为是引用数据类型，赋值之后地址会被覆盖得。所以打印对象得时候就会打印出覆盖后得地址值。
变量分类的详解：
2.变量分类有哪些?
①成员变量(面向对象也叫字段)
静态的[类变量]:通过类名.变量名访问的变量
非静态的[实例变量]:实例即对象：通过对象访问的变量是实例变量
②局部变量：不能使用static修饰
局部变量得作用;
一般都是方法中，为了辅助方法完成功能而临时定义的变量
4.2什么是包
1.学习理解：什么是包？ 暂时看成是文件夹
2.Java包概念：包（package）是Java提供的一种区别类的名字空间的机制，是类的组织方式，是一组相关类和接口的集合，它提供了访问权限和命名的管理机制。
3.为了方便管理类：分别存入不同的包（文件夹）
4.3包作用
可以管理代码结构
2.可以避免类名冲突的问题
一个项目中有可能多个类名一样
操作系统中同一个文件夹中不能存在相同名字的两个文件
4.4如何使用包
语法 : package cn.itsource.erp.oa.domain;
.包命名规范：一般是 公司域名 反过来写 + 项目名+模块名字+子模块名
包名中应该全部都是英文，并且是小写的
a)包的必须在源文件的顶部最开始位置申明
b)同一个源文件中可以有多个类，编译生成的字节码文件都会在该包下面
package cn.itsource.crm.oa.domain;
class Test{//文件名也是Test
public static void main(String[] args) {
System.out.println(“Hello 小姐姐你好呀”);
}
}
class Student{
static String name;
}
2.包的导入
包的导入（其实本质是导入包中的类到本类中）
1.在一个类中需要使用到其它的包中的类，可以先导入在便捷的使用
2.目的： 是为了正确的引用到指定的类型
3.注意： 导入包的代码应该在声明包的后面，声明类的前面
4.导入的语法 ：
1)import 包名.子包名.类名；
2)import 包名.子包名.*;//*通配符，通配该类所在的子包名
3)通一个类中用到了java.util.Date java.sql.Date 导入会区别不了二异，所以通过完全限定名的方式使用
4)java.lang这是Java规定的核心包，使用的时候会自动导入，所以不用手动导入
一般都自动导入包，但是要记住相对应得类是那个包下边得。
包得分类：
java.lang (java的核心包–基本包)
java.util(java的工具包 --集合框架)
java.io(java IO包 读写文件)
java.net(网络编程)
java.awt/javax.swing（java的图形化界面GUI）
5.封装（面向对象三大特性之一）
1.想一想生活中封装是什么？包装 ：快递 ：打包
.台式机电脑：机箱[ 主板 显卡 内存 电源 硬盘。。。]必须要装起来，不然透露了不安全有可能会被偷，所以就需要封装起来。
5.2 Java中的封装如何体现
在字段或者方法前边加入private来修饰，是别人不能够访问得到该字段和方法。
通过给类中的成员（字段，方法，构造方法）添加访问权限来实现访问控制
4.访问权限修饰符： private < 默认不写（注意不要添加default修饰）< protected < public
private ：私有的 最小权限，被它修饰的成员只能够在本类中可以访问到；
public ：公共的 最大权限，任何地方和任何人都能访问；
在私有化的同时给外界提供一个构造器，通过构造器来进行相应的访问。这就是加密，封装。
class Student{
private String name;private int age;
private boolean sex;
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
public void setAge(int a){
age = a;
}
public int getAge(){
return age;
}
public void setSex(boolean s){
sex = s;
}
public boolean isSex(){
return sex;
}
}
可以在主方法去通过创建对象，传入相对应的参数来取出字段的值。
封装小结：
1.在Java 中的体现及步骤
1)把类中的字段私有化；
2)给每一个字段都提供一组getter setter方法 (方法的规范写法)；setXxx
在测试类中尝试创建对象,并通过调用getter setter方法完成 对字段的赋值和取值；
3)提供一个无参数的构造方法
注意：
1)能否把一个字段的get 和set方法写成一个方法
i.不可取（比如 当我只是取值的时候，还需要传入参数，这不好）
2)一个类中的多个字段的赋值方法 写成一个方法
i.不可取 耦合度太高(万一我们只想给某一个字段赋值)
3)单一职能原则:功能最小化,不要想着一个方法写完所有的功能
4.给对象的字段赋值 一共有哪些方式：
通过构造方法赋值 只能够创建对象的时候赋初始值
3)通过setXxx方法赋值 更灵活；
setXxx 这么好是否就可以不要构造方法了呢？
两者不冲突，一般可以在创建的时候赋值，也可以后面进行修改
4)字段必须私有化
5)给每一个字段提供合理的getter setter方法
6)必须有一个公共的无参数的构造方法;
6.this
1.this的概念：this指代当前对象，持有当前对象的地址
2)this当前被对象持有，this就指代谁，模板---->复印件
6.this不能写在静态的方法中 : 无法从静态上下文中引用非静态 变量 this
(1)static类级别
(2)this对象级别
1.解决局部变量和成员变量的二义性 — get set 方法中的应用[在get/set可以写this]
2.作为返回值返回 ： this持有对象地址，表示该类的一个对象即是一个数据
3作为参数传递
4本类中构造方法之间的相互调用
继承（面向对象三大特征之一）
3)原则：父类存放共性，子类存放特性
把子类共有的方法和字段提取到父类进行存放。然后自己在继承父类即可
三个类都有重复的代码，可以把这部分内容 抽出去，抽出去放到另外一个类里面；.上面的类我们叫做 父类（超类，基类，根类）
下面的类我们叫做 子类（派生类，拓展类）
提取好处 : 提高了代码的复用性
2 Java中类继承的基本语法:
class Animal{}
class Person extends Animal{} //目标就是为了继承到Animal,这个类型
A 就是B的父类; B是A的子类
class Animal{
String name;
void eat(){
System.out.println(“吃实物”);
}
}
class Person extends Animal{
}
class Pig extends Animal{
}
子类可以继承父类，共享父类的字段和方法；
3 子类可以从父类继承哪些成员？
可以继承父类的非私有化的字段和方法；
2.4 Java中类的继承特点
1只能够是单继承，不能够多继承
一个儿子只能有一个亲生父亲。（Object类是所有类的父类，超级类）
2.可以支持多重继承
可以支撑多个子类来继承这个父类，当没有显示的写出继承的父类的时候，及隐士的继承到了Object超类。
继承总结
1.继承的基本语法
class Animal{
}
class Person extends Animal{
}
class Pig extends Animal{
}
2.继承到父类的那些东西
(1)非私有的字段及方法
(2)父类特性
3.继承的特点
(1)单继承
(2)多重继承
(3)没有显示的继承,那么隐式的继承Object
3. 方法覆写（覆盖，重写，Override）
为什么需要方法覆写：
当父类的功能不能够满足子类的需求时，就需要方法的覆写
方法覆写的基本语法：
b)补充：子类的动态描述父类的动态描述不一致
把父类的方法拷贝到子类中，修改方法体，功能重新实现【覆盖，覆写Override】
1.明确为什么需要复写：当父类的方法不满足子类的需求的时候，需要覆写
基本语法：直接将父类中需要覆写的方法复制放入子类，修改方法体 （修改功能执行语句）
3.子类方法是否在覆写父类的方法,可以通过注解@Override验证
通过就时覆写了，没通过就表示不是覆写
1)注解:跟注释很类似
2)注释:给程序员看的
3)注解:给java程序看的
class Animal{
void move(){
System.out.println(“移动”); }
}
class Person extends Animal{
void move(){//复制父类方法，方法体功能语句重新实现
System.out.println(“走动”);
}
}
这就时方法的覆写；
方法覆写的细节：
1)保证子类方法和父类方法的方法签名(方法名+参数列表)一致;
就是返回值类型，方法名和传入的参数必须保持一致；
2)访问权限 : 子类方法的访问权限(修饰符)不能够比父类方法的访问权限更低;
3)static 方法不能够被覆写
构造方法不能被继承；
5)方法主体 : 方法覆写,子类方法和父类方法主体是否可以一样, 可以! 但是没有什么用!
不建议把父类的方法和子类的方法写的一样，那样子覆写就没有意义了；
父类存放共性，子类存放特性；
覆写就是子类方法存放的特性；
方法覆写总结：
1.为什么需要方法复写
(1)当父类的方法不满足子类的需求的时候需要复写
2.方法复写的基本语法[ 最常用 ]
(1)复制父类的方法到子类中,之后修改复制到子类中的方法体
(2)是否是覆写可以通过注解@Override 写在子类被覆写的方法头,
①是覆写编译通过
②不是覆写编译报错
4.Object类（及方法覆写的应用）是所有类的超类
Object类【所有类的根类】超类，父类
1.每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object
2.Object是每一个类的，直接父类或者间接父类
3.Object所有类的根类,是一个非常重要的类,所有类的重要的公共的静态属性，及动态行为[方法]都被提取到了Object
1.类 Object 是类层次结构的根类,每个类都使用 Object 作为超类。[备注：接口没有关系]
2.所有对象[包括数组]都实现这个类的方法 : 所有的对象[数组]都可以调用到Object中的方法;
1)Student s = new Student();
s.hashCode(); 可以的
2)String s2 = “等等”;
s2.hashCode();可以的
3)int[] arr = new int[6];
arr.hashCode();可以的4)
int i = 5；//基本类型数据不是对象
i.hashCode();//不可以的
基本数据类型不是对象所以不能够调用方法。
Object类里面的方法：
String toString() 返回调用此方法的当前对象的字符串表示形式(把当前对象转成字符串)
boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
2.明确什么是对象描述：静态描述，姓名 年龄 …
3.实际打印地址值：不符合对于对象的描述
class Test {
public static void main(String[] args) {
Student stu = new Student(“小花花”,18);
//System.out.println(stu);//覆写前：Student@15db9742
System.out.println(stu);//覆写后：小花花 - 18
}
}
class Student{
String name;
int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + " - " +age;
}
}
不覆写的话打印的是地址，用地址来描述一个对象的属性不合适，所以覆写了toString用字符串来描述对象更加的合适；
6.覆写toString方法的意义及什么时候需要覆写toString
a)意义：自定类创建的对象可以准确的打印对象描述
b)什么时候需要覆写：自定义类需要打印对象描述的时候
打印出对象地址值的时候，不够直观我们就覆写，直接用字符串的形式来描述对象更清晰。
c)如果使用java中写好的类创建对象，打印的不是地址值，说明该类已经覆写过了toString
b)覆写之后为什么打印的是覆写后的对象描述:就近原则使用的是自己的toString
Object中的equals方法使用分析
1)boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
基本数据类型比较用==
引用数据类型比较用equals
class Test {
public static void main(String[] args) {
Student stu1 = new Student(“小花花”,18);
Student stu2 = new Student(“小花花”,18);
boolean result = stu1.equals(stu2);
System.out.println(result);//false
}
}
class Student{
String name;
int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + " - " +age;
}
}
这两个对象的属性是相等的，但是没有覆写equals比较的却是对象的地址值，
所以我们覆写toString 的意义只是为了让对象的属性进行比较。
5.Object中equals方法比较对象地址，不符合现实生活中比较对象的规则！java代码的对象比较，因该是静态属性的比较，父类Object中equals方法比较对象：不满足子类对象比较静态属性的需求，需要覆写
覆写Object中的equals方法：
基本语法：
boolean result = stu1.equals(stu2);
public boolean equals(Object obj){
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age = stu.age;
}
在比较对象属性的时候我们可以用instanof来判断一下，类型是否向对应；
1.什么时候需要覆写Object中的equals方法,及覆写的意义
(1)什么时候需要覆写自定义类对象,相互之间需要比较对象的静态属性的时候!
(2)覆写的意义:能够需求,正确的比较对象,静态属性
==和equals的区别：
相等 : a 传统的理解一般都是数字值是否相等;
b 在程序中任何东西都是数据,都会比较是否相等[ 对象 ]
2. == 比较运算符
1)基本数据类型变量: 比较的就是值是否相等;
引用数据类型变量: 比较的是对象的地址是否一样;（排除特殊 String）
- 基本数据类型 : 不能够使用! 基本数据类型不是对象,不能够调用Object中的方法
- 引用数据类型 : 但是在Object的源码中定义的就是 == 进行比较比较
4.定义好的类没有覆写过equals方法，则会直接调用到了Object中的equals方法,那么本质还是在使用比较
5.在实际开发中,自定义类：一般比较对象，都是通过对象的属性值进行比较,所以自定义类，会经常覆在自定义的类中写Object中的此方法,把自己的比较规则写在方法里面;
比较基本数据类型： 比较对象用 equals方法
五.访问权限修饰符：
1.权限修饰符 ： private < 默认不写（注意不要添加default修饰）< protected < public
2.作用 ： 主要是控制类以及类中成员的访问权限
要知道哪些东西能被修饰：主要是修饰类中的成员（字段 方法 构造方法， 内部类）
都不能够修饰局部变量
1)如果不希望别访问，私有化private权限
2)如果希望别人访问，提供公共的权限public
3)如果特殊情况：权限由小到大设置
多态（面向对象三大特诊之三）
回顾this
1.this的概念：this表示当前对象，持有当前对象的地址
2this当前被哪个对象持有this就指代谁
3通过this访问当前对象中的成员(字段,方法);区分成员变量与局部变量的二义性
4 把this(当前对象)看成是一个数据, 就可以作为值返回,作为参数传递…
5 使用场景-2 : 本类中构造方法的之间的方法体第一句相互调用;
i.this(); 调用本类中无参数的构造方法;
ii.this(123); 调用本类中具有一个int参数的构造方法;
2.super(简单)
2.super的概念：在子类中表示父类的对象
3.区别this：super不持有父类对象地址
使用场景：
1.前提：super访问父类的成员，都必须是在有访问权限的条件之下;
2.super访问父类对象中的字段 及 普通方法;
class User{//父类User
String name = “小花花”;
void login(){
System.out.println(“User login”);
}
}
class StudentUser extends User{//子类 StudentUser
String name = “中花花”;
void eat(String name){
System.out.println("super.name = "+super.name);//super访问父类字段
super.login();//super访问父类普通方法
System.out.println("name = "+name);
System.out.println("this.name = "+this.name);
}
}
class Test {//有主方法的测试类Test
public static void main(String[] args) {
StudentUser stu = new StudentUser();
stu.eat(“大花花”);
}
}
---------- Java ------------------------------------------------------
super.name = 小花花
User login
name = 大花花
this.name = 中花花
3.在子类的构造方法体第一句访问父类的构造方法; 最常用的!!!
1)super(); 调用父类无参数的构造方法;
2)super(123); 调用父类中具有一个int参数的构造方法;
super的特殊使用场景：
在子类的构造方法第一句，调用父类的构造方法；
如果没有显示的写出对于父类构造方法的调用，那么会隐式的调用父类的无参数的构造方法
b)如果有显示的写出对于父类构造方法的调用，那么会隐式的调用父类的无参数的构造方法，就不存在了！
子类的构造方法中一定会调用到父类的构造方法
无论如何，子类的构造方法一定会存在对于父类构造方法的调用（不管写不写，只要继承到了父类，那么就会默认的调用父类的构造方法和普通方法）
a)私有化字段在子类getset可以用到的原因
因为是隐士存在调用了父类的构造方法；
标签：封装,name,继承,覆写,面向对象,Student,子类,父类,方法 来源： https://blog.csdn.net/dkwjava/article/details/88859606