第一部分:基础知识【C】
- Equals ==
- For each
第二部分:面向对象
-
封装(encapsulation,有时也称为数据隐藏)
-
类:对一类事物抽象所得到的一个概念,“模板”,“蓝图”。
//Java中,最简单的类定义形式: class ClassName { field1 field2 field3 ... constructor1//构造器 constructor2 constructor3 ... method1 method2 method3 .... }
//一个简单的Employee类。在编写薪金管理系统时可能会用到 class Employee { //instance fields private String name; private double salary; private LocalDate hireDay; //constructor public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; hireDay = LocalDate.of(year, month, day); } //a method public String getName() { return name; } //more method ... }
类与类之间的关系:
- 依赖(“uses-a”)
- 一个类的方法操作另一个类的对象,就认为一个类依赖另一个类
- 聚合(“has-a”)
- 聚合关系意味着类A的对象包含类B的对象
- 继承(“is-a”)
- 如果类A扩展类B,类A不但包含从类B继承的方法,还会拥有一些额外的功能,具体继承内容在👇
- 依赖(“uses-a”)
-
对象:一个具体的事物(用关键字new出来的,女朋友除外)
- 三个主要特征:
- 对象的行为(behavior):可以对对象施加哪些操作,或可以对对象施加哪些方法?
- 对象的状态(state):当施加那些方法时,对象如何响应?
- 对象标识(identity):如何辨别具有相同行为与状态的不同对象?
- 三个主要特征:
-
构造函数(构造器):
-
没有返回值
-
方法名与类名相同
-
可以有多个构造函数
-
当没有显式写出构造函数时,默认是无返回值、无参的构造函数,其状态(成员变量)会被设置成适当的默认值。
//以下是Employee类的无参数构造函数: public Employee() { //name = ""; //所有将对象(字符串类型本事就是一个String类对象)变量设置为null //salary = 0; //所有的数值类型设置为0,如果存在boolean类型,则设置为false //hireDay = LocalData.now(); }
-
如果自己显式(即自己手动定义一个构造函数),则编译器将不再生成默认无参的构造函数
-
生成一个类对象时,能且只能调用其中一个构造函数
-
构造器总是伴随着new操作一起调用
-
不要在构造器中定义与类的成员变量(实例域)重名的局部变量
{ String name = n; //ERROR double salary = s; //ERROR .... /* 这个构造函数声明了局部变量name和salary。这些变量只能在构造器的内部访问。 这些变量屏蔽了同名的成员变量(实例域)。 */ }
-
-
static:
-
属于类本身的成员变量
private static int nextId = 1;
或者方法public static void getNextId();
class Employee { //如果将域定义为static,每个类只有一个这样的域(成员变量)。而每一个对象对于所有的实例域(非static成员变量)却都有自己的一份拷贝,此处假定需要给每一个雇员赋予唯一的标识码。这里给Employee类添加一个实例域id和一个静态域nextId; ... private static int nextId = 1; //静态变量 private int id; ... public static void getNextId() //静态方法,一般很少使用 } -------------------------- public class Math { ... public static final double PI = 3.14159265358979323846; //静态常量,带关键字final ... }
-
静态成员不可以访问非静态的成员,因为静态成员属于类本身,不属于任何独立的对象。可以在不具有实例(对象)的条件下直接通过类本身调用
Employee.getNextId();
(此处假设有一个Employee的类),但是非静态成员可以访问静态成员 -
通过类名也不一定能够访问
static
修饰的静态成员,通过类名只能访问此类中非私有的静态成员。 -
可以使用对象调用静态方法。不过这种方式很容易造成混淆,其原因是静态方法的反馈结果与某个对象毫无关系。所以建议使用类名,而不是对象来调用静态方法。
在下面两种情况下使用静态方法:
- 一个方法不需要访问对象状态,其所需参数都是通过显式参数提供(例如:
Math.pow
)。 - 一个方法只需要访问类的静态域(例如:
Employee.getNextId
。)
- 一个方法不需要访问对象状态,其所需参数都是通过显式参数提供(例如:
-
-
this指针:具体this函数详解👉 JAVA入门—this指针,懂这个就够用了!.
- 引用隐式参数。
- 调用该类的其他构造器
- 非静态成员方法默认都含有一个this指针,代表正在调用本方法的对象
-
函数重载:
- 方法同名,形式参数必须不同
- 返回值不能够作为是否构成函数重载的依据。
-
final:
- 修饰类:不允许扩展的类被称为final类。希望阻止利用此类来定义子类。如果将一个类声明为final,只有其中的方法自动地称为final,而不包括成员变量(域)。
- 修饰方法:该方法可以被继承,但是不能重写
- 修饰成员变量:该成员变量在构建对象时必须被初始化,也就是说,在每个构造器执行之后,这个变量的值被设置。并且后面的操作中,不能够再对其进行修改。
-
封装部分具体实例:
import java.time.LocalDate; class Employee { private String name; private double salary; private LocalDate hireDay; public Employee() { //如果第二个构造器没有,则编译器自动生成此无参构造函数,若第二个👇构造函数显式定义,则编译器不再自动生成此无参数构造函数 } public Employee(String name, double salary, int year, int month, int day) //第二个构造器 { this.name = name; this.salary = salary; hireDay = LocalDate.of(year, month, day); } public String getName() { return name; } public double getSalary() { return salary; } public LocalDate getHireDay() { return hireDay; } public void raiseSalary(double byPercent) { double raise = salary*byPercent/100; salary += raise; } } class Manager extends Employee { private double bonus; /** * 物理结构已经继承来自Employee类的三个成员变量,只是不可以显式调用 */ public Manager(String name, double salary, int year, int month, int day) { super(name, salary, year, month, day); bonus = 0; } public double getSalary() { double baseSalary = super.getSalary(); return baseSalary+bonus; } public void setBonus(double b) { bonus = b; } } public class ManagerTest { public static void main(String[] args) { Manager boss = new Manager("Carl Creacker",80000,1987,12,15); boss.setBonus(5000); Employee[] staff = new Employee[3]; staff[0] = boss; staff[1] = new Employee("Harry Hacker",50000, 1989, 10, 1); staff[2] = new Employee("Harry Li",40000, 1990, 3, 15); for(Employee e : staff) { System.out.println("name is "+e.getName()+",salary="+e.getSalary()+",hireDate"+e.getHireDay()); } } } ```
-
-
继承(inheritance):"is-a"关系
-
基于已存在的类构造一个新类。继承已存在的类就是复用(继承)这些类的方法和成员变量(私有成员变量物理上被继承,但是实际子类无法使用,故通常认为,私有成员没有被继承)。在此基础上,还可以添加一些新的方法和成员变量,以满足新的需求。
public class Manager extends Employee { //添加特有的方法和域名(成员变量) }
-
extends表明正在构造的新类派生于一个已存在的类。已存在的类称为父类(parent class);新类称为子类(subclass)。
-
覆盖方法(方法的重写) 具体方法重写详解👉 JAVA-入门 函数重写.
- 如果父类中的有些方法对子类并不一定适用。为此,需要提供一个新的方法来覆盖(override)父类中的这个方法。
- 重写方法必须和被重写方法具有相同的方法名称、参数列表、返回值且***访问权限***不能低于父类中被覆盖的方法(相同方法名)的访问权限。特别是,如果父类方法是public,子类方法一定要声明为public。经常会发生这类错误:在声明子类方法的时候,遗漏了public修饰符。此时,编译器会将它解释为试图提高更严格的访问权限。
-
-
多态 具体多态详解👉 JAVA-入门 多态.
-
有一个用来判断是否应该设计为继承关系的简单规则,就是"is-a"规则,它表明子类的每个对象也是父类的对象。"is-a"规则的另一种表述方法是置换法则。它表明程序中出现父类对象的任何地方都可以用子类对象置换。即可以将一个子类的对象赋给父类变量
对象://此处假设Manager是Employee的子类 Employee e; e = new Employee(....); //Employee object expected e.getName(); //此处调用的是Employee类中的getName()方法 e = new Manager(...); //OK, Manager can be used well. e.getName(); //此处调用的是Employee类的子类Manager中的getName()方法 //4、6行同一代码执行不同的操作,就是多态的表现 //在Java程序设计语言中,对象变量是多态的。一个Employee变量既可以引用一个Employee类对象,也可以引用一个Employee类的任何一个子类的对象(例如,Manager、Secreatary等)。
-
同一个代码可以随着上下文的不同而执行不同的操作,俗尘多态。
-
注意事项:
- 如果父类的引用指向子类的对象,则通过父类的引用只能访问子类从父类继承过来的成员,即此时不能够访问子类特有的成员。
- 如果想通过父类的引用去访问子类的特有方法,必须满足两个条件:
- 父类引用指向子类的对象
- 父类被强制转化为子类类型的引用
-
-
相关知识:
-
抽象类:
-
包含一个或多个抽象方法的类本身必须被声明为抽象类,
/**抽象类还可以包含具体数据和具体方法*/ public abstract class Person { private String name; .... public abstract String getDescription(); ... public String getName() { return name; } }
如果自下而上在类的继承层次结构中上移,位于上层的类更具有通用性,甚至更加抽象。从某种角度看,祖先类更加通用。我们只将它作为派生其他类的基类,而不作为想使用特定的实例类。
-
抽象方法充当着占位的角色,它们的具体实现在子类中。扩展抽象类可以有两种选择。一种是在抽象类中定义部分抽象方法或不定义抽象类方法,这样就必须将子类也标记为抽象类;另外一种是定义全部的抽象方法,这样子类就不是抽象的了。
-
类即使不含有抽象方法,也可以将类声明为抽象类。
-
因为抽象类不能被实例化。也就是说,如果将一个类声明为
abstract
,就不能创建这个类的对象。new Person("pan ye chen"); //Error,但可以创建一个已经全部实现父类中抽象方法的具体子类的对象。
-
需要注意的是,可以定义一个抽象类的对象变量,但是它只能引用非抽象子类的对象。例如
Person p = new Student("pan ye chen", "nanjinguniversity"); //这里的p是一个抽象类Person的变量,Person引用了一个非抽象子类Student的实例。
-
下面定义一个扩展抽象类
Person
的具体子类Student
:class Student extends Person { private String major; public Student(String name, String major) { super(name); this.major = major; } public String getDescription() { return "a student majoring in" + major; } }
-
-
-
-
具体程序示范:
/** * Time : 2020-06-07 * */ import java.time.LocalDate; abstract class Person { public abstract String getDescription(); //此处不能省略,否则变量p就不能调用getDescription方法了。 //编译器只允许调用在类中声明的方法。 private String name; public Person(String name) { this.name = name; } public String getName() { return name; } } class Employee extends Person { private double salary; private LocalDate hireDay; public Employee(String name, double salary, int year, int month, int day) { super(name); this.salary = salary; hireDay = LocalDate.of(year, month, day); } public double getSalary() { return salary; } public LocalDate getHireDay() { return hireDay; } public String getDescription() { return String.format("an employee with a salary od $%.2f",salary); } public void raiseSalary(double byPercent) { double raise = salary * byPercent/100; salary += raise; } } class Student extends Person { private String major; public Student(String name, String major) { super(name); this.major = major; } public String getDescription() { return "a student majoring in" + major; } } public class PersonTest { public static void main(String[] args) { Person[] people = new Person[2]; //fill the people array with Student and Employee objects people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1); people[1] = new Student("Maria Morris", "computer science"); //print out names and descriptios of all Person objects for(Person p : people) { System.out.println(p.getName()+","+p.getDescription()); } } }
是否可以省略
Person
父类中的抽象方法,而仅仅在Employee
和Student
子类中定义getDescription()
方法呢?答案是否定的,如果这样的话,就不能通过变量p调用getDescription()
方法了。编译器只允许调用在类中声明的方法。-
接口:
-
在Java程序设计语言中,接口不是类,而是对类的一组需求描述,这些类要蹲从接口描述的统一格式进行定义。
-
接口的所有的成员变量(域)自动地属于
public static final
,接口中所有的方法自动地属于public abstract
.因此,在接口中声明成员变量和方法时,不必提供自动的关键字。 -
每个类只能够拥有一个父类,但却可以实现多个接口,从而侧面填补了无法多重继承的缺点。使用逗号将实现的各个接口分隔开。
class Employee extends Person, implements Cloneable, Comparable //此处继承extends关键字必须写在实现implements关键字之前,否则ERROR
-
接口的特性:
- 接口不是类,尤其不能使用
new
运算符实例化一个接口:
- 接口不是类,尤其不能使用
interface Comparable { ...... } public Employee implements Comparable x = new Comparable(...); //error //然而,尽管不能构造接口的对象,却能声明接口的变量; Comparable x; //OK //接口变量必须引用实现了接口的类对象: x = new Employee(....); //OK, provided Employee implements Comparable
-
为了让类实现一个接口,通常需要下面两个步骤:
- 将类声明为实现给定的接口
-
对接口中所有方法进行定义,因为其方法都是
public abstract
类型,如果没有全部实现,则此类为抽象类。
-
-
-
内容扩展:
- 归纳Java中用于可见性的4个访问修饰符:
- 仅对本类可见—private
- 对所有类可见—public
- 对本包和所有子类可见—protected
- 对本包可见—默认(default), 不需要修饰符。
- 归纳Java中用于可见性的4个访问修饰符:
-
良好的编程习惯:
-
需要获得或设置实例域的值。应该提供下面三项内容
- 一个私有的数据域
- 一个公有的域访问器方法(
public 数据类型 Getter
) - 一个公有的域更改器方法。(
public void Setter
)
-
类设计技巧:
-
识别(定义)类的简单规则
-
在分析问题的过程中寻找名词
-
方法对应着动词
举例:
在订单处理系统中,有这样一些名词:
- 商品(Item)
- 订单(Order)
- 送货地址(Shipping address)
- 付款(Payment)
- 账户(Account)
这些名词很可能成为类Item、Order等。
接下来,查看动词:商品被添加到订单中,订单被发送或取消,订单货款被支付。对于每一个动词如:“添加”、“发送”、“取消"以及"支付”,都要标识出主要负责完成相应动作的对象。例如,当一个新的商品添加到订单中,那个订单对象就是被指定的对象,因为它知道如何存储商品以及对商品进行排序。也就是说,add应该是Order类的一个方法,而Item对象是一个参数。
当然,所谓"找名词和动词"原则只是一种经验,在创建类的时候,哪些名词和动词是重要的完全取决于个人的开发经验。
-
-
一定要保证数据私有
- 这是最重要的;绝对不要破坏封装性,当数据保持私有时,它们的表现形式的变化不会对类的使用者产生影响,即使出现bug也易于检测。
-
一定要对数据初始化
- Java不对局部变量进行初始化,但是会对对象的实例域(成员变量)进行初始化。最好不要依赖与系统的默认值,而是应该显式地初始化所有的数据,具体的初始化方式可以式提供默认值,也可以是在所有构造器中设置默认值。
-
不要在类中使用过多的基本类型
-
就是说,用其他的类代替多个相关的基本类型的使用。这样会使类更加易于理解且修改。例如,用一个称为Address的新的类替换一个Customer类中以下的实例域:
private String street; private String city; private String state; private int zip;
这样,可以很容易处理地址的变化,例如,需要增加对国际地址的处理。
-
-
不是所有的域(成员变量)都需要独立的域访问器和域更改器
-
将指责过多的类进行分解
-
优先使用不可变的类
-
类名和方法名要能够体现他们的指责 Java多态笔记代码.
- 与变量应该有一个能够反映其含义的名字一样,类也应该如此。命名类名的良好编程习惯是采用一个名次(Order)、前面有形容词修饰的名词(Rush Order)或动名词(有"-ing"后缀)修饰的名词(例如,BillingAddress)。对于方法来说,习惯是访问器方法用小写get开头(getSalary),更改器方法用小写的set开头(setSalary).
本篇介绍了Java这种面向对象语言的有关对象和类的基础知识。
-
-