ACCP8.0 java课程第二学期-关于类和对象

Posted 2020-09-16

本章重点:构造函数，封装，重载
本章难点: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