第一部分：基础知识【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这种面向对象语言的有关对象和类的基础知识。
-
-
1018
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
