@MRsunhuimin
2021-10-22T17:40:38.000000Z
字数 5631
阅读 197
总结
大骆驼命名法 类 UserService
小骆驼命名法 方法 shouName()
属性 userName user_name username $username
高内聚 低耦合
多聚合 少继承
包 com.公司名.项目名.包名
类：具有相同属性和方法的一组类的集合类是对象的抽象，对象是类的具体。
定义类：
public class 类名（）{//定义属性部分属性1的类型 属性1；···属性n的类型 属性n；//定义方法部分方法1；···方法n；}
创建对象：
类名 对象名 = new 类名（）；School center = new School();
引用成员对象，使用“.”进行以下操作:
引用类的属性： 对象名.属性
引用类的方法： 对象名.方法名（）
center.name = "洛阳师范学院";//给name属性赋值center.schoolCenter();//调用showCenter()方法
访问修饰符 返回值类型 方法名（）{//这里编写方法的主体}
对象名.方法名(参数1，参数2，...参数)；
常见错误：
//方法定义public void addName(String name){//方法体}//方法调用对象名.addName(String "张三")；// String 错误 调用方法时不能指定实参类型！
//方法定义public boolean searchName(int start ,int end ,String name){//方法体}//int int String//方法调用String s="开始"; //Stringint e=3;String name="张三";boolean flag=对象名. searchName(s ,e ,name);//形参和实参数据类型需要保持一致！数量也要保持一致！
public class Test {public void calc1(int num){num=num+1;}public void calc2(Student student){student.age=student.age+1;}}
//测试类Test test=new Test();int n=8;test.calc1(n);Student stu=new Student();stu.age=18;test.calc2(stu);System.out.println(n+"---"+stu.age);//输出结果 8---19
基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。
引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用。
构造方法
访问修饰符 构造方法名（）{//初始化代码}//无参的构造方法，与类同名，不含返回类型。如果类中没有无参的构造方法，系统会给出默认的无参构造方法。//构造方法一般都是public 的，才能被系统调用。
作用：对象初始化
Student s1 = new Student();//无参构造方法Student s2 = new Student("张三"，21)；//有参构造方法
构造方法的重载
自定义构造方法
1.方法名相同
2.参数项不同
3.与返回值，访问修饰符无关
此时系统不再提供默认无参构造方法
//调用属性this.health = 100;this.name = "大黄";
//调用方法this.print();
//调用构造方法this();//无参this（"小黑",100,100,"雄"）;//有参（如果使用，必须是构造方法的第一句）
1.在同一个类中
2.方法名相同
3.参数个数或类型不同
4.与返回值、访问修饰符无关
成员变量包括类变量（以static修饰）和实例变量（不以static修饰）
类变量从该类的准备阶段起开始存在，直到系统完全销毁这个类，类变量的作用域与这个类的生存范围相同；
而实例变量则从该类的实例被创建起开始存在，直到系统完全销毁这个实例，实例变量的作用域与对应实例的生存范围相同。
基于这个原因，可以把类变量和实例变量统称为成员变量。其中类变量可以理解为类成员变量，它作为类本身的一个成员，与类本身共存亡；实例变量则可以理解为实例成员变量，它作为实例的一个成员与实例共存亡。
只要类存在，类就可以访问类变量 类.类变量
只要实例存在，实例就可以访问实例变量 实例.实例变量
当然实例也可以访问类变量。但是需要注意的是因为实例不拥有类变量，所以通过实例来访问类变量进行操作，实际上是对类变量进行操作 ，当有其他实例来访问类变量时，访问的类变量是被对象访问操作过的类变量。
成员变量无需显示初始化，只要为一个类定义了类变量或实例变量，系统就会在这个类的准备阶段或创建该类的实例时进行默认初始化。
局部变量根据定义形式的不同，又可以分为如下三种：
形参：在定义方法签名时定义的变量，形参的作用域在整个方法中都有效
方法局部变量：在方法体内定义的局部变量，它的作用域是从定义该变量的地方生效，到该方法结束时失效
代码块局部变量：这个局部变量的作用域从定义该变量的地方生效，到该代码结束时失效。
一个变量只在一对{}中起作用。。
java允许局部变量和成员变量同名，如果方法中局部变量和成员变量同名，局部变量就会覆盖成员变量，如果需要在这个方法中引用被覆盖成员变量，则可使用this（对于实例变量）或类名（对于类变量）作为调用者来限定访问成员变量。
成员变量的作用域在整个类的内部都是可见的
局部变量的作用域仅限于定义它的方法
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
在同一个方法中，不允许有同名局部变量
在不同方法中，可以有同名局部变量
在同一个类中，成员变量和局部变量同名时，局部变量优先级更高
概念
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐蔽信息的操作和访问（把尽可能多的东西藏起来，对外提供便捷的接口）
如何实现封装
1.修改属性的可见性（设为private,防止错误的修改）
2.创建共有的getter/setter方法（用于属性的读写）
3.在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）
封装的优点
1.便于使用者正确使用系统，防止错误修改属性
2.有助于系统之间的松耦合，提高系统独立性
3.提高软件的可重用性
4.降低了构建大型系统的风险
1.命名规范
1.包名由小写字母组成，不能以圆点开头或结尾
如： package mypackage;
2.包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
如： packagenet.javagroup.mypackage;
包名后续部分依不同机构内部的规范不同而不同
如： package net.javagroup.research.powerproject;
2.导入方法
为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类
import 包名. 类名；
import java.util.*; //导入java.util包中所有类import cn.jtest.classandobject.School;//导入指定包中指定类
1. 系统包：java.util
2. 自定义包：cn.jtest.classandobject
*： 指包中的所有类
School ：指包中的School类
3.注意事项
1.一个类同时引用了两个来自不同包的同名类时必须通过完整类名来区分
2.每个包都是独立的，顶层包不会包含子包的类
3.package和import的顺序是固定的
package必须位于第一行（忽略注释行）
只允许有一个package语句
其次是import
接着是类的声明
| 修饰符\作用域 | 同一类中 | 同一包中 | 子类 | 任何地方 |
|---|---|---|---|---|
| private | √ | × | × | × |
| 默认修饰符 | √ | √ | × | × |
| protected | √ | √ | √ | × |
| public | √ | √ | √ | √ |
类的成员变量包括:
1.类变量（静态变量）
被static修饰的变量
在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问
2.实例变量
没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响
静态方法：可直接通过类名访问
1.静态方法中不能使用this和super
2.不能直接访问所属类的实例变量和实例方法
3.可直接访问类的静态变量和静态方法
4.静态方法必须被实现；main()是最常用的静态方法
实例方法：通过实例访问
可直接访问所属类的静态变量、静态方法、实例变量和实例方法静态方法必须被实现
子类访问父类成员
//访问父类构造方法super();super(name);
//访问父类属性super.name;
//访问父类方法super.print();
（1）使用super关键字,super代表父类对象
（2）在子类构造方法中调用且必须是 " 第一句"
（3）不可以访问父类中定义为private的属性和方法
（4）Java中只支持单根继承，即一个类只能有一个直接父类
子类继承父类的什么？
继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里
继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里
子类可以继承父类的所有资源吗？
不可以，子类不能继承的父类资源包括:
（1）private成员
（2）子类与父类不在同包，使用默认访问权限的成员
（3）构造方法
方法的重写或方法的覆盖（overriding）
（1）子类根据需求对从父类继承的方法进行重新编写
（2）重写时，可以用super.方法的方式来保留父类的方法
（3）构造方法不能被重写
方法重写的的规则
（1）方法名相同
（2）参数列表相同
（3）返回值类型相同或者是其子类
（4）访问权限不能严于父类
（5）父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
（6）子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
（7）父类的私有方法不能被子类覆盖
（8）不能抛出比父类方法更多的异常
方法重写VS方法重载
| 比较项 | 位置 | 方法名 | 参数表 | 返回值 | 访问修饰符 |
|---|---|---|---|---|---|
| 方法重写 | 子类 | 相同 | 相同 | 相同或是其子类 | 不能比父类更严格 |
| 方法重载 | 同类 | 相同 | 不相同 | 无关 | 无关 |
Object类是所有类的父类
1.普通类VS抽象类
（1）普通类可以被实例化，普通类有方法体
(2) 抽象类不能被实例化，抽象类没有方法体
2. 抽象类与抽象方法的使用
（1）抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
（2）如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
（3）没有抽象构造方法，也没有抽象静态方法
（4）抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
（5）抽象类不能实例化对象，抽象类本身也不能被实例化，只能被继承
（6）抽象类使用abstract来修饰
3.接口interface
（1）接口不可以被实例化
（2）实现类必须实现接口的所有方法
（3）实现类可以实现多个接口，使用implements,多个接口用逗号隔开
（4）接口中的变量都是静态常量，即 public static final
4.面向接口编程
（1）接口是一种“能力”
（2）在程序设计时，关心实现类有何能力，而不关心实现细节；面向接口的约定而不考虑接口的具体实现。
5.接口使用
（1）接口中的成员变量默认都是public static final的，必须显示初始化；
（2）接口中的方法默认都是public static的；
（3）接口没有构造方法，不能被实例化；
（4）一个接口不能实现另一个接口，但可以继承多个其他接口；
（5）一个类必须实现接口抽象方法（implements），除非这个类也是抽象类
6.抽象类vs接口
相同点：
（1）代表系统的抽象层
（2）都不能被实例化
（3）都能包含抽象方法
（4）用于描述系统提供的服务，不必提供具体实现
不同点：
（1）在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法
（2）抽象类便于复用，接口便于代码维护
（3）一个类只能继承一个直接的父类，但可以实现多个接口
使用原则：
（1）接口做系统与外界交互的窗口
（2）接口提供服务
（3）接口本身一旦制定，就不允许随意修改
（4）抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点
7.总结
Java中的接口：
（1）属性全都是全局静态常量
（2）方法都是全局抽象方法
（3）无构造方法
一个类可以实现多个接口，非抽象类实现接口时必须实现接口中的全部方法
抽象类利于代码复用，接口利于代码维护
1、new关键字Person p1 = new Person();2.Class.newInstancePerson p1 = Person.class.newInstance();3.Constructor.newInstanceConstructor<Person> constructor = Person.class.getConstructor();Person p1 = constructor.newInstance();4.clonePerson p1 = new Person();Person p2 = p1.clone();5.反序列化Person p1 = new Person();byte[] bytes = SerializationUtils.serialize(p1);Person p2 = (Person)SerializationUtils.deserialize(bytes);