Java复习回顾---7月8日回顾练习
敬上几个单词：
visible 可见的 insert 插入，嵌入 complete 完全的，完整的 fix 解决方法
blank 空白的 field 场地，田地 initialized 初始化的 available 可得到的
面向对象的特性：
封装性 继承性 多态性
类的设计和对象的创建使用：
package cn.ftf.practice01;
public class Em01 {
public static void main(String[] args) {
Persion01 p1=new Persion01();
p1.age=12;
p1.print();
System.out.println(p1.age);
}
}
class Persion01{
int age;
String name;
void print() {
System.out.println("我正在学习！");
}
}
类的封装
1 package cn.ftf.practice01;
2 /**
3 * 类的封装
4 * @author 房廷飞
5 *
6 */
7 public class Em02 {
8 public static void main(String[] args) {
9 Persion p1=new Persion();
10 p1.setName("房廷飞");
11 p1.setAge(81);
12 System.out.println(p1.getAge()+"\n"+p1.getName());
13 }
14 }
15 class Persion{
16 private String name; //类的属性一般私有化，加private
17 private int age;
18 public String getName() { //自动添加set，get方法
19 return name;
20 }
21 public void setName(String name) {
22 this.name = name;
23 }
24 public int getAge() {
25 return age;
26 }
27 public void setAge(int age) {
28
29 if(age>0&age<100) {
30 this.age = age;
31 }else {
32 System.out.println("请输入正确的年龄！");
33 }
34
35 }
36
37 }
构造方法，有参的构造方法和构造方法的重载：
1 package cn.ftf.practice01;
2
3 public class Em03 {
4 public static void main(String[] args) {
5 Person p1=new Person(22,"ftf",222);
6 p1.speak();
7 }
8
9
10 }
11 class Person{ //有参的构造方法和构造方法的重载
12 int age;
13 String name;
14 int hight;
15
16 public Person(int age, String name, int hight) {
17 super();
18 this.age = age;
19 this.name = name;
20 this.hight = hight;
21 }
22
23
24 public Person(int age, String name) {
25 super();
26 this.age = age;
27 this.name = name;
28 }
29
30
31 public void speak() {
32 System.out.println(name+age+"岁了！"+hight);
33 }
34 }
this关键字作用：
//作用一：访问成员变量，this.表示类的什么东西
//作用二：调用构造方法，可以在一个构造方法中调用另一个构造方法
//作用三：调用成员方法，虽然可有可无
举例说明:
1 package cn.ftf.practice01;
2 /**
3 * this关键字作用
4 * @author 房廷飞
5 *
6 */
7 public class TestThis {
8 int a,b,c;
9
10 public TestThis(int a, int b) {
11 this.a = a; //作用一：访问成员变量，this.表示类的什么东西
12 this.b = b;
13 }
14
15 public TestThis(int a,int b,int c) {
16 this(a,b); //作用二：调用构造方法，可以在一个构造方法中调用另一个构造方法
17 this.c = c;
18 }
19 void sing() {
20 System.out.println("唱歌！！！");
21
22 }
23 void eat() {
24 this.sing(); //作用三：调用成员方法，虽然可有可无
25 System.out.println("回家吃饭！！！");
26 }
27 public static void main(String[] args) {
28 TestThis th=new TestThis(1, 2,3);
29 th.eat();
30 }
31
32
33
34 }
static关键字使用
//static第一个作用：所修饰的成分被所有类的实例对象所共享
//第二个作用：静态方法不需要实例化对象就i可以调用
//第三个作用：使用静态代码块对成员变量进行初始化，由于类只加载一次，静态代码块只执行一次
举例说明：
1 package cn.ftf.practice01;
2 /**
3 * static关键字作用
4 * @author 房廷飞
5 *
6 */
7 public class TestStatic {
8 public static void main(String[] args) {
9 Stu st1=new Stu();
10 Stu st2=new Stu();
11 System.out.println(st1.schoolName);
12 System.out.println(st2.schoolName);
13 Stu.print();
14 }
15
16 }
17
18 class Stu{
19 static String schoolName="河南工业大学"; //static第一个作用：所修饰的成分被所有类的实例对象所共享
20 static void print(){
21 System.out.println("第二个作用：静态方法不需要实例化对象就i可以调用"); //第二个作用：静态方法不需要实例化对象就i可以调用
22 }
23 static {
24 System.out.println("静态代码块执行了！"); //第三个作用：使用静态代码块对成员变量进行初始化，由于类只加载一次，静态代码块只执行一次
25 }
26 }
27
28 /*
29 打印结果：
30 静态代码块执行了！
31 河南工业大学
32 河南工业大学
33 第二个作用：静态方法不需要实例化对象就i可以调用
34 */
下面是一个银行新用户现金业务小程序设计，用来综合练习静态变量及静态方法的使用，this 关键字的使用。
项目工程文件：
Bank.java
1 package cn.ftf.bank;
2
3 public class Bank {
4 static String bankName;
5 private String name;
6 private String password;
7 private double balance;
8 private double turnover;
9 static void print1() {
10 System.out.println("欢迎来到"+bankName);
11 }
12 static void print2() {
13 System.out.println("欢迎您下次光临！！！");
14 }
15 public Bank(String name, String password, double turnover) {
16 super();
17 this.name = name;
18 this.password = password;
19 this.turnover = turnover;
20 }
21 public void deposit(double turnover) {
22 balance=turnover+balance;
23 System.out.println("存入"+turnover+"元，余额为"+balance);
24 }
25 public void withdrawal(String password,double turnover) {
26 if(this.password!=password) {
27 System.out.println("输入密码错误！！！");
28 return;
29 }
30 else if(balance-turnover>0) {
31 balance=balance-turnover;
32 System.out.println("您已取款成功"+turnover);
33 }else {
34 System.out.println("余额不足!");
35 }
36 }
37 }
Trade.java
1 package cn.ftf.bank;
2
3 public class Trade {
4 public static void main(String[] args) {
5 Bank.bankName="华夏银行";
6 Bank.print1();
7 Bank b=new Bank("房廷飞","666666",2345.11);
8 b.deposit(1000);
9 b.withdrawal("66666", 666);
10 b.withdrawal("666666", 666);
11 b.withdrawal("666666", 66666666);
12 Bank.print2();
13
14 }
15
16 }
ectends继承和super关键字的作用及使用
1 package cn.ftf.practice01;
2
3
4 class Animal{
5 String name="动物";
6 void shou() {
7 System.out.println("发出叫声！");
8 }
9 }
10 class Dog extends Animal{
11 String name="大黄";
12 void shou() {
13 System.out.println("重写父类！汪汪汪");
14 }
15 public void printName() {
16 System.out.println("name="+name);
17 System.out.println("使用super访问父类属性：name="+super.name); //super指父类的属性和方法
18 super.shou();
19 }
20 }
21 public class TestExtends {
22 public static void main(String[] args) {
23 Dog dog=new Dog();
24 //dog.name="大黄";
25 dog.printName();
26 dog.shou();
27
28
29 }
30
31 }
32
33 /*打印结果：
34 name=大黄
35 使用super访问父类属性：name=动物
36 发出叫声！
37 重写父类！汪汪汪
38 */
final关键字三个作用：
1，类（class）被final修饰后不能被继承
2，final所修饰的方法不能被重写
3，final修饰的变量不能被更改（再次赋值），且不赋初值时变量为null
加油！！！
