标签：封装 name 继承 覆写 面向对象 Student 子类 父类 方法
面向对象的特征（封装、继承、多态）
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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。