本章重点:构造函数，封装，重载本章难点:static关键字 this关键字 1.面向过程与面向对象的区别面向过程是在Main函数中完成功能，从开始到结束，一步一步的实现功能面向对象是各个类之间协同工作，相互影响，需要考虑哪些类，有什么属性和方法 2.如何使用面向对象进行编程2.1 抽象出类(找名词)2.2 定义属性(找特征)2.3 定义方法(找行为或者动词)
1 /
2 *
3 * 现在有这样一个例子，小张到买了一个冰淇淋，他挺高兴的
4 * 1.首先我们找名词发现出小张(人)，冰淇淋(物)这两个类
5 * 2.第二步找人有哪些特征 我们发现了名字(小张)，满意度(高兴)的特征
6 * 3.第三步发现人有哪些行为 我们通过示例发现了“买”这个动作
7 */
8 public class Person{
9 private String name;//名字
10 private int love;//满意度
11
12 public void setName(String name){
13 this.name = name;
14 }
15
16 public String getName(){
17
18 return this.name
19 }
20
21 /**
22 * 购买的方法
23 */
24 public void buy(SomeThing st){
25
26 }
27
28 }
29 class Something{
30
31 private String name;
32
33 public String getName(){
34 return name;
35 }
36 }
3.构造函数3.1 用于类进行初始化的相关操作3.2 无返回值3.3 如果类不定义构造函数，都会提供一个默认的构造函数3.4 构造函数支持重载
1 /**
2 * Created by niechen on 17/4/18.
3 */
4 public class Test3 {
5
6 public Test3() {
7 System.out.println("这个是默认的构造函数");
8 }
9
10 public Test3(int number) {
11 System.out.println("这是一个number构造函数");
12 }
13
14 public Test3(String text) {
15 this(10);
16 System.out.println("这是一个Text构造函数");
18 }
19
20 public Test3(String... text) {
21 System.out.println("这也是一个构造函数");
22 }
23 //该方法有返回值 所以只是个普通的方法
24 public void Test3() {
25 System.out.println("这只是一个普通的方法");
26 }
27
28 public static void main(String[] args) {
29 new Test3();
30 }
31 }
4.static关键字4.1 static关键字可以定义在成员变量，方法，静态区域及内部类上4.2 static方法不能直接调用非静态成员的属性与方法4.3 static可用于所有对象的共享数据4.4 类加载的时候，就被赋值了4.5 静态内存-》静态代码块-》构造方法 (多个静态代码块按照顺序进行执行)
/** * 示例代码 *
* Created by niechen on 17/4/18.
*/
public class Test4 {
public static int age = 10;
public static int number;
static {
age--;
System.out.println("静态代码块中输出age:" + age);
}
static {
age--;
System.out.println("第二个静态代码块中输出age:" + age);
}
Test4() {
number++;
System.out.println("构造函数里输出age:" + age);
}
public static int test() {
System.out.println(age);
return age;
}
public static void main(String[] args) {
new Test4();
new Test4();
Test4.test();
System.out.println("创建对象的个数:" + Test4.number);
}
public static class Test2 {
}
输出结果： 静态代码块中输出age:9 第二个静态代码块中输出age:8 构造函数里输出age:8 构造函数里输出age:8 8 创建对象的个数:2
5.this关键字5.1 可以区分于方法参数与成员变量5.2 this指的是当前的引用对象，在内存中开辟一个内存块引用自己5.3 用于在构造函数中调用其他构造函数,必须放在第一行代码中
1 package org.lyrk.accp8.s2.chapter.one;
2
3 /**
4 * Created by niechen on 17/4/18.
5 */
6 public class Test5 {
7 private int number;
8 private String name;
9
10 public Test5(int number, String name) {
11 this.name = name;//this关键字作用之一当参数与属性名相同时,区分内部属性还是入参参数
12 this.number = number;
13 }
14
15 public Test5() {
16 this(10, "你好");//this关键字作用之一调用本类中的其他构造函数
17 System.out.println("这个是默认构造函数");
18 }
19
20 public Test5 setName(String name) {
21 this.name = name;
22 return this;//this关键字作用之一返回当前的引用对象
23 }
24
25 public Test5 setNumber(int number) {
26 this.number = number;
27 return this;
28 }
29
30 public static void main(String[] args) {
31 Test5 test5 = new Test5().setName("张三").setNumber(10);
32 System.out.println(test5.name);
33 System.out.println(test5.number);
34 }
35
36 }
6.关于常量6.1 用于描述无需改变的数值6.2 它是静态的不可变的，使用static final进行修饰 （书上只用final修饰） 7.关于封装7.1 对内实现具体细节，对外提供方法供于调用7.2 内部成员变量用private修饰符修饰，对外提供getter setter方法7.3 public > protected(第二章会讲到) > package(不加访问修饰符) > private 8.关于重载8.1 必须在同一个类，方法名相同，参数列表不同(方法参数的个数或参数类型不同)，与方法返回值和方法修饰符没有任何关系8.2 重载匹配方法规则由精确到模糊，直到找到合适的方法为止
package org.lyrk.accp8.s2.chapter.one;
/**
* Created by niechen on 17/4/17.
*/
public class Test8 {
public static void test(int t1) {
System.out.println(t1 + "int");
}
public static void test(char t1) {
System.out.println(t1 + "char");
}
public static void test(double t1, double t2) {
System.out.println(t1 + t2);
}
public static int test(String c,String s){return 0;}
//public static int test(int t1){return 0;}
public static void test(int t1, double t2) {
System.out.println(t1 - t2);
}
public static void test(Integer t1, double t2) {
System.out.println("Integer:" + (t1 - t2));
}
public static void main(String[] args) {
test(10,2.0);
test(‘c‘,2);
}
}
输出结果：
8.0
97.0
时间： 2024-10-07 23:17:46