目录
一、面向对象
1.面向对象学习的三条主线
1、java类以及类的成员：
属性 方法 构造方法 代码块 内部类
2、面向对象的三大特征：
封装性、继承性、多态性（抽象性
3、其它关键字
this super package import static final abstract interface
2.类和对象的使用
- 创建类 设计类的成员
- 创建类的对象
- 通过"对象名.属性"对象名.方法名调用对象的属性方法
如果创建一个类的多个对象则每个对象都独立的拥一套类的属性
注意：如果修改了一个对象的属性a则不影响另一个对象的属性值a的值
类中属性的使用
3.成员变量 vs 局部变量
1、相同点
- 定义格式 数据类型 变量名 = 变量值
- 先声明 在使用
- 变量都有自己的作用域
2、不同点
2.1定义的位置不同
- 属性：直接定义在类的{}里面
- 局部变量：声明在方法内、方法的的参数、代码块、构造器内部的变量
2.2作用范围不一致
- 从声明她开始到包含他最近的大括号
2.3关于权限修饰符的不同
- public private 缺省 protected
- 属性：可以在声明属性时，使用访问权限修饰符指明其权限
- 局部变量：不可以加以访问权限修饰符
2.4默认初始化的值
- 属性：类的属性，根据其类型，都有默认初始值
- 整型4个：0
- 浮点型2个：0.0
- 字符型1个：0
- 引用数据类型：null
- boolean:false
- 局部变量：没有默认初始化的值
2.5在内存中的位置不同
- 属性：加载到堆空间中（非static）
- 局部变量：加载到栈空间中
- 属性（成员变量）
- 定义在类里面，作用域范围整个类里面
- 可以访问权限修饰符 public private 缺省 protected
- 有默认初始化值（可以只进行声明）
- 在堆空间中（非static）
2.6局部变量：
- 定义在方法 形参 代码块 构造方法（形参）中
- 没有访问权限修饰符
- 没有默认值（使用前必须声明+初始化）
- 在栈空间
成员变量和局部变量
| 成员变量 | 局部变量 | |
| 声明的位置 | 直接声明在类中 | 方法形参或内部、代码块内、构造器内等 |
| 修饰符 | private、public、static、final等 | 不能用权限修饰符修饰， 可以用final修饰 |
| 初始化值 | 有默认初始化值 | 没有默认初始化值， 必须显式赋值， 方可使用 |
| 内存中加载的位置 | 堆空间或静态域内 | 栈空间 |
二、构造器（构造方法）
1.描述
- 和类的名称相同
- 不声明返回值类型
- 不能被static、final、synchronized、abstract、native等修饰，不能有return返回值
2.作用：创建对象、给对象初始化
Person p = new Person("zs","18");3.格式
修饰符 类名 （参数列表）{
初始化语句；
}
public Person() {
System.out.println("父类无参构造");
}
public Person(String name,int age) {
System.out.println("父类有参构造");
}
4.根据参数的不同可以分为两类
隐式无参构造器（系统默认提供，创建有参构造之后就没有了）
显式定义一个或多个
注意点：
① Java语言中，每个类都至少有一个构造器（系统默认提供）
② 默认构造器的修饰符与类的修饰符一致
③ 一旦显式定义了构造器， 则系统不再提供默认构造器
④ 一个类可以创建多个重载的构造器
⑤ 父类的构造器不可被子类继承
三、this
1.Java中，this关键字的作用很重要，使用在：
- 它在方法内部使用，及这个方法所属对象的引用；
- 他在构造器内部使用，表示该构造器正在初始化的对象。
- this可以调用类的属性、方法和构造器。
2. this的使用
- this可以用来修饰、调用属性、方法、构造器
- this修饰 属性 方法
- this理解为：当前的对象 或 当前正在创建的对象
- 在类的方法中，通过如下方式调用对象的属性和方法
- this.属性通常情况下会将this省略，特殊情况下，如果方法的形参类的属性同名，必须显示使用"this.变量"的方式表明此变量是属性，而非形参（this.方法）
- this调用构造器
- this(参数列表)
- ①在构造器类通过this调用构造方法，必须放在方法的第一行。
- ②构造器不能通过this(参数)的方式调用自己
- ③如果类中有n个构造器，则最多有n-1个构造器中this(形参)
- ④一个构造器中只能声明一个"this(形参列表)"用来调用其他东西
this什么时候使用呢？
当前方法内部需要用到调用该方法的对象时，就用this。
访问修饰符
Java的权限修饰符在类的成员之前，用来限定对象对该类成员的访问权限。
| 修饰符 | 本类 | 同一个包 | 不同包 | 同一项目 |
| private | √ | |||
| 缺省 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
属性赋值的先后顺序
①默认初始化：int age;
②显式初始化：int age = 1;
③在代码块中赋值
④构造器中初始化：person p = new Person(12);
⑤通过"对象.方法名 /（对象名.属性）方式赋值
先后顺序：①-->②/③-->④-->⑤
四、封装
1. 封装的原则和实现步骤
封装的原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。
封装的实现步骤
- 使用 private 关键字来修饰成员变量。
- 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。
- 在公共方法（getXxx方法、setXxx方法）中加入控制语句
- private是访问权限修饰符，代表最小权限。被private修饰后的成员变量和成员方法，只在本类中才能访问。
- 通过使用访问控制修饰符来限制对对象属性的访问，可以获得 3 个重要的好处。
- 防止对封装数据的未授权访问。
- 有助于保证数据完整性。
- 当类的私有实现细节必须改变时，可以限制发生在整个应用程序中的“连锁反应”。
2. 代码实例
public class User {
private String name; // 姓名
private int age; // 年龄
private String phone; // 联系电话
private String address; // 家庭住址
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
// 对年龄进行限制
if (age < 18 || age > 40) {
System.out.println("年龄必须在18到40之间！");
this.age = 20; // 默认年龄
} else {
this.age = age;
}
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
五、实例
1.银行管理系统（开户、存取）
public class Person2 {
//人 有名字、年龄、银行卡
String name;
int age;
Debit debit;
//必须写无参构造器
public Person2() {
}
public Person2(String name, int age){
this.name=name;
this.age=age;
}
//人 开户
public void openAccount(Debit debit){
this.debit=debit;
debit.show();
show();
}
//人 存款
public void in(double money){
debit.balance+=money;
System.out.println("存款成功:"+debit.balance);
}
//人 取款
public void out(double money){
if (money <= debit.balance){
debit.balance-=money;
System.out.println("取款成功:"+debit.balance);
}else {
System.out.println("账户余额不足:"+debit.balance);
}
}
//展示
public void show(){
System.out.println("姓名:"+name+",年龄:"+age);
}
public boolean valid(String pass){
if ( pass== debit.password){
return true;
}
return false;
}
}
//银行卡类
public class Debit {
//属性
String cardId;
String password;
double balance;
//无参构造器
public Debit(){
}
//有参构造器
public Debit(String cardId, String password, double balance) {
this.cardId = cardId;
this.password = password;
this.balance = balance;
}
//展示
public void show() {
System.out.println("卡号" + cardId + "余额" + balance);
}
}
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
//键盘输入
Person2 person = new Person2("张三", 25);
Scanner sc = new Scanner(System.in);
boolean fl = true;
while (fl) {
System.out.println("请选择功能: 1.开户 2.存款 3.取款 4.退出");
String flag = sc.next();
switch (flag) {
case "1":
System.out.println("请输入账号");
String num = sc.next();
System.out.println("请输入密码");
String pass = sc.next();
System.out.println("请输入余额");
double money1 = sc.nextDouble();
Debit debit = new Debit(num, pass, money1);
person.openAccount(debit);
break;
case "2":
System.out.println("请输入密码");
String pass1 = sc.next();
boolean b = person.valid(pass1);
if (b) {
System.out.println("请输入存款金额：");
double money = sc.nextDouble();
person.in(money);
} else {
System.out.println("密码有误，无法进入");
}
break;
case "3":
System.out.println("请输入密码");
String pass2 = sc.next();
boolean p = person.valid(pass2);
if (p) {
System.out.println("请输入取款金额：");
double money2 = sc.nextDouble();
person.out(money2);
} else {
System.out.println("密码有误，无法进入");
}
break;
case "4":
fl = false;
break;
}
}
}
}2.员工管理系统
//员工管理系统 注册登录
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// User类型的数组
// User类型的数中保存的就是一个一个的User对象
// 当从User类型的数组中取值的时候，比如说users[0]是一个User类型的对象
User[] users = new User[10];
int index = 0;
// User user=new User();
// users[0]=user;1
for (; ; ) {
System.out.println("请选择功能：1、注册 2、登录");
String flag = sc.next();
switch (flag) {
case "1":
System.out.println("请输入账号：");
int username = sc.nextInt();
System.out.println("请输入密码：");
int password = sc.nextInt();
// 保存账号密码，保存的是User对象
// 构建User对象
User user = new User(username, password);
users[index] = user;
System.out.println("注册成功，账号：" + username + "，密码：" + password);
index++;
break;
case "2":
System.out.println("请输入账号：");
int username1 = sc.nextInt();
System.out.println("请输入密码：");
int password1 = sc.nextInt();
//
boolean b = false;
for (User u : users) {
if (u != null) {
if (u.getUserword() == password1 && u.getUsername() == username1) {
b = true;
break;
}
}
}
if (b) {
System.out.println("登录成功");
Demo01 demo01 = new Demo01();
demo01.foo();
} else {
System.out.println("登陆失败");
}
}
}
}
}public class Demo01 {
public void foo(){
Scanner scanner = new Scanner(System.in);
System.out.println("欢迎使用员工管理系统：");
int[] nos = new int[2];
String[] names = new String[2];
boolean flag1 = true;
int i = 0;
while(true) {
label75:
while(flag1) {
System.out.println("请选择功能：1、添加员工 2、查询员工 3、修改员工 4、删除员工 5退出系统");
int c = scanner.nextInt();
int x;
int p;
switch(c) {
case 1:
System.out.println("请输入员工姓名:");
String name = scanner.next();
names[i] = name;
int oldid = 1001 + i;
nos[i] = oldid;
System.out.println("工号：" + nos[i] + "姓名" + name + "添加成功");
System.out.println("欢迎进入员工系统");
i++;
if (i < nos.length) {
break;
}
int[] newnos = new int[nos.length + 1];
String[] newnames = new String[names.length + 1];
for(p = 0; p < nos.length; ++p) {
newnos[p] = nos[p];
newnames[p] = names[p];
}
nos = newnos;
names = newnames;
break;
case 2:
System.out.println("请输入员工编号:");
boolean f = false;
int num = scanner.nextInt();
for(p = 0; p < nos.length; ++p) {
if (num == nos[p]) {
System.out.println("员工编号是：" + num + "员工姓名是：" + names[p - 1]);
f = true;
}
}
if (!f) {
System.out.println("员工不存在");
}
break;
case 3:
System.out.println("请输入员工号：");
boolean e = false;
int num1 = scanner.nextInt();
for(x = 0; x < nos.length; ++x) {
if (num1 == nos[x]) {
System.out.println("员工编号是：" + num1 + "员工姓名是：" + names[x]);
System.out.println("请输入要修改的姓名");
String name1 = scanner.next();
names[x] = name1;
System.out.println("修改后的员工号和姓名是：" + num1 + names[x]);
e = true;
break;
}
}
if (!e) {
System.out.println("员工不存在");
}
break;
case 4:
System.out.println("请输入要删改工号：");
x = scanner.nextInt();
int y = 0;
while(true) {
if (y >= nos.length) {
continue label75;
}
if (x == nos[y]) {
nos[y] = nos[nos.length - 1];
nos = Arrays.copyOf(nos, nos.length - 1);
names[y] = names[names.length - 1];
names = (String[])Arrays.copyOf(names, names.length - 1);
System.out.println("删除成功");
}
++y;
}
case 5:
flag1 = false;
System.out.println("退出系统");
}
}
return;
}
}
}
public class User {
private int username;
private int userword;
public User(){}
public User(int username, int password) {
this.userword=password;
this.username=username;
}
public void setUsername(int username) {
this.username = username;
}
public void setUserword(int userword) {
this.userword = userword;
}
public int getUsername() {
return username;
}
public int getUserword() {
return userword;
}
}
六、心得体会
今天还好，把昨天的又复习了一下，能跟上了，就是写着有点费劲，不过还是能听懂，自己能写出一些了，还是挺累的，坐的腰都疼了，哎！！！
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
