系列文章目录
记录java核心技术学习笔记
文章目录
目录
前言
面向对象程序设计概述
使用预定义类
自定义类
静态字段和静态方法
一、面向对象程序概述
示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
1.1.面向对象概述
面向对象程序有对象组成，每个对象包含对用户公开的特定功能和隐藏的实现。
1.2.类
类（class）：指定了如何构造对象。由一个类构造(construct)对象的过程称为创建这个类的一个实例（instance）。
封装（encapsulation）:信息隐藏，是处理对象的一个重要概念。封装就是将数据和行为组合在一个包中，并对对象的使用者隐藏具体的实现细节。对象的数据称为实例字符安（instance field），操作数据的过程称为方法（method）
1.3.对象
对象的三个主要特性：
对象的行为（behavior）：可以对这个对象做哪些操作，或者可以对这个对象应用哪些方法？
对象的状态（state）：调用那些方法时，对象会如何响应？
对象的标识（identity）:如何区分可能有相同行为和状态的不同对象？
对象的这些关键特性会彼此相互影响。例如：对象的状态会影响它的行为（如果一个订单“已发货”或“已付款”，就应该拒绝要求增删商品的方法调用。反过来，如果订单是“空的”，即还没有订购任何商品，就不应该允许“发货”）
1.4.识别类
识别类的一个简单经验就是在分析问题的过程中寻找名称。方法就是寻找动词
比如：
商品（Item）
订单（Order）
发货地址（Shipping address）
付款（Payment）
账户（Account）
从这些名称中可以得到类 Item Order等
方法就是寻找动词 ：比如添加，发货，付款等等
1.5.类与类直接的关系
常见的关系有:
依赖（use-a）：如果一个类的方法要使用或操作另一个类的对象，就说前一个类依赖后 一个类
聚合（“has-a”）：包含 关系意味这类A的对象包含类B的对象
继承（“is-a”）：一般跟特殊的关系。表示一个特殊类与一个更一般的类之间的关系
二、使用预定义类
2.1.对象与对象变量
要使用对象，首先必须构造对象，并指定其初始状态，然后对对象应用方法
//构造一个Date对象
new Date();
//将对象存放在一个变量中
Date rightnow = new Date(); //此时rightnow 就是一个对象变量
//对象与对象变量之间存在一个重要区别 例如以下语句
Date startTIme; //对象变量没有引用任何对象，此时startTime不是一个对象
//如果此时执行如下语句会报错
String s = startTIme.toString(); //not yet
//此时有两个选择，1.初始化这个变量，让它用一个新构造的对象
startTime = new Date(）；
// 2.也可以设置这个变量，让它引用一个已有的对象
startTime = rightNow();
tip:注意到一个重要的的点:
对象变量并不实际包含一个对象，它只是引用一个对象
2.2.java类库中的LocalDate类
标准的java类库分别包含了两个类：一个是用来表示时间点的Date类，另一个是日历表示法表示日期的LocalDate类
//不要使用构造器来构造LocalDate类的对象。实际使用静态工厂方法，他会代表你调用构造器
LocalDate.now();
//可以提供年 月 日 来构造对应一个特定日期的对象
LocalDate.of(1999,12,31)
//将构造的对象存入一个对象变量中
LocalDate newYearsEve = LocalDate.of(1999,12,31);
//可以调用对象中方法获取年 月 日
int year = newYearsEve.getYear; //1999
int month = newYearsEve.getMonth; //12
int dat = newYearsEve.getDay; //31
下面是相关api：
static LocalDate now() //构造一个表示当前时间的对象
static LocalDate of(int year, int month, int day)//构造一个表示给定日期的对象
//得到当前 日期的年月日
int getYear();
int getMonthValue();
int getDayOfMonth();
//得到当前日期的星期几，DayOfWeek 类的一个实例返回。在DayOfWeek实例上调用getValue来得到1~7之间得到一个数，表示这是星期几，1表示星期一
DayOfWeek getDayOfWeek();
//生成当前日期之后或之前n天的日期
LocalDate plusDays(int n) //之后
LocalDate minusDays(int n) //之前
2.3.LocalDate测试案例
public static void main(String[] args) {
//初始化时间
LocalDate date = LocalDate.now();
//获取月份
int month = date.getMonthValue();
//获取获取当天
int today = date.getDayOfMonth();
//让日期为月初
date = date.minusDays(today-1);
//获取月初为星期几
DayOfWeek weekday = date.getDayOfWeek();
//获取数字星期几
int value = weekday.getValue();
System.out.println("MON TUE WED THU FRI SAT SUN");
while (date.getMonthValue()==month){
System.out.printf("%3d",date.getDayOfMonth());
if(date.getDayOfMonth()==today){
System.out.print("*");
}else {
System.out.print(" ");
}
date =date.plusDays(1);
if (date.getDayOfWeek().getValue()==1) System.out.println();
}
}
MON TUE WED THU FRI SAT SUN
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25* 26 27 28
29 30 31三、自定义类
3.1.自定义Employee
class Employee{
private String name ;
private double salary;
private LocalDate hireDay;
//构造器与类同名，构造对象时会执行这个方法，会初始化
public Employee(String n, double s, int year, int month, int day) {
name =n;
salary = s;
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;
}
}3.2.从构造器开始
构造器与类同名
每个类都可以有一个以上的构造器
构造器可以有0个，一个或多个参数
构造器没有返回值
构造器总是结合new操作符一起调用
在方法中引入与属性相同的字段记得带this
3.3.用var声明局部变量
在java 10 中，如果可以从变量的初始值推导出他们的类型，可以用var关键字。
例如
var hary = new Employee("Haryy hacker",5000,1989,10,1);
注意：var关键字只能用于方法中的局部变量。参数和字段的类型必须声明
3.4.使用null引用
对象变量必须包含一个对象的引用，或者包含一个特殊值null（表示没有引用任何对象）
如果对null值引用一个方法，会报空指针异常
如：
LocalDate rightNow = null;
String s = rightNow.toString(); // NullPointerException
3.5.隐式参数和显示参数
public void raiseSalary(double byPercent){
double raise = salary*byPercent /100;
salary += raise;
}
byPercent 入参：显示参数；
salary 隐式参数
这个方法还可以这样写
public void raiseSalary(double byPercent){
double raise = this.salary*byPercent /100;
this.salary += raise;
}3.6.封装的优点
1.可以改变内部实现
2.更改器方法可以完成错误检查
3.6.类的访问权限，私有方法，final实例字段
实现一个类时，我们会将所有实例字段都设置成私有字段，因为公共数据很危险。方法大多是是公共的。有时候私有方法也是很有用的。比如一个方法是私有的，你改变了方法的具体实现，并没有义务保证这个方法依然可用。
重点在于，只要方法私有的，类的设计者就可以确信它不会在别处使用。
如果一个方法是公共的，就不能简单的删除，因为可能会有其他代码依赖这个方法。
可以将实例字段定义为final，这样的字段必须在构造对象时初始化，必须确保每一个构造器执行之后，这个字段的值已经设置，并且以后不能修改这个字段。这个字段没有set方法。
常用与基本类型与不可变的字段。
对于可变类使用final修饰符可能会造成混乱。比如如下字段
private final StringBuilder evaluations；
StringBuilder有append方法，能够修改这个字段。所以不要对可变类型使用final关键字。
四、静态字段和静态方法
4.1.静态字段，
静态字段属于类，不属于单个对象
静态变量使用较少，使用较多的是静态常量。
比如Math类中定义了一个 PI
4.2.静态方法
静态方法是不操作对象的方法。例如Math求幂方法
Math。pow(x,a);//计算幂 它并不使用Math任何对象来完成这个任务
可以任务静态方法没有this参数的方法。
静态方法不能访问非静态字段，只能访问静态字段。
调用方式 ： 类名.方法名（当然对象调用静态方法也是合理的）
下面两种情况可以使用静态方法：
方法不需要访问对象状态，因为它需要的所有参数都通过显示参数提供
方法只需要访问类的静态字段
4.3.工厂方法
静态方法还有另外一种常见的用途-静态工厂来构造对象
省略。。。。。后续补充
五、方法参数
5.1.程序清单
利用程序清单方法参数的要点
/**
* java 语言是按值调用，也就是说方法会得到所有参数值的一个副本，方法不能修改传递给它的任何参数变量的内容
* java 对对象采用的是按值传递的不是按引用调用。实际上 对象引用是按值传递的
*
* 总结：
* 方法不能修改基本数据类型的参数（即数值型 布尔型）
* 方法可以改变对象参数的状态
* 方法不能让一个对象参数引用一个新对象
*/
public class ParamTest {
public static void main(String[] args) {
/**
* 测试1
*/
System.out.println("Testing tripleValue:");
double percent = 10;
System.out.println("Before : percent: "+percent);
tripleValue(percent);
System.out.println("after : percent: "+percent);
/**
* 测试2
*/
System.out.println("Testing tripleValue:");
Employ harry = new Employ("Harry", 50000);
System.out.println("Before : percent: "+harry.getSalary());
tripleSalary(harry);
System.out.println("after : percent: "+harry.getSalary());
/**
* 测试3 测试交换
*/
System.out.println("Testing swap:");
Employ alice = new Employ("Alice", 70000);
Employ bob = new Employ("Bob", 60000);
System.out.println("Before : Alice: "+alice.getName());
System.out.println("Before : Bob: "+bob.getName());
swap(alice,bob);
System.out.println("after : Alice: "+alice.getName());
System.out.println("after : Bob: "+bob.getName());
}
/**
* 调用这个方法不生效，调用之后的值还是原有的值，方法结束后参数变量X不在使用
* 不过有两种不同的类型参数
* 基本数据类型： 数字，布尔型
* 对象引用
*
* 一个方法不可能修改基本数据类型的参数，而对对象类型参数不同
* @param x
*/
public static void tripleValue(double x){
x = 3*x;
System.out.println(x);
}
//获取长薪工资
/**
* 实现方法可以改变对象参数的状态，方法得到的是对象应用的副本，原来对象引用和这个副本引用同一个对象
* @param x
*/
public static void tripleSalary(Employ x){
x.raiseSalary(200);
System.out.println(x.getSalary());
}
//交换方法
/**
* 这个方法没有改变存储在 变量 alice 和 bob 的对象引用。 swap 方法的参数 x 和 y 初始化为两个对象引用的副本。这个方法交换的是这两个副本。
* 方法结束时参数 x y 被丢弃了。原来变量的引用仍然是调用之前的对象
* @param x
* @param y
*/
public static void swap(Employ x, Employ y){
Employ temp = x;
x = y;
y = temp;
System.out.println(x.getName());
System.out.println(y.getName());
}
}
class Employ{
private String name ;
private double salary;
public Employ(String n, double s){
name = n;
salary = s;
}
public String getName() {
return name;
}
public double getSalary() {
return salary;
}
public void raiseSalary(double byPercent){
double raise = salary*byPercent /100;
salary += raise;
}
}总结
好好学习，天天向上
努努力力，扎扎实实
恋恋不忘，必有回响
恋恋不忘，必有回响
6408
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
