Day5:面向对象的定义(中)

    1、面向对象的特点------封装性

    /*
    封装:隐藏实现细节,对外提供公共的访问方式。
    
    1,安全性。
    2,复用性。
    3,隔离的变化。后期应用于分层设计。
    
    
    
    */
    /*
    描述人:
    属性:姓名,年龄。
    行为:说话。
    */
    
    class Person
    {
        private String name;
        private/*私有*/ int age;
        /*
        将成员变量私有化,对外提供set get方法,对其访问的原因就是可以属性可控。
    
        私有关键字private 是一个权限修饰符,只能修饰成员(成员变量,成员函数)。
    
    
        注意:私有仅仅是封装的表现形式之一!
    
        */
    
        public void setName(String s)
        {
            name = s;
        }
        public String getName()
        {
            return name;
        }
    
        public void setAge(int a)
        {
    
            /*可以加入健壮性的判断。
            if(a<=0 || a>120)
                throw 
            */
                age = a;
            
        }
        public int getAge()
        {
            return age;
        }
    
    
        void speak()
        {
            System.out.println(name+":"+age);
        }
    }
    
    
    class PersonDemo
    {
        public static void main(String[] args) 
        {
            Person p = new Person();
    //        p.name = "旺财";
    //        p.age = -20;
            p.setName("旺财");
            p.setAge(20);
            p.speak();
        }
    }

     

    2、this关键字

    /*
    this关键字。
    1,区分局部变量和成员变量同名的情况。
    用this标识的是成员变量。
    
    this到底是个啥呢?
    this其实就代表对象,代表哪个对象呢?
    哪个对象调用了this所在的函数。this就指向哪个对象。
    (this就代表着当前这个对象)
    
    */
    
    
    class Person
    {
        private String name;
        private int age;
    
        Person()
        {
            this.name = "baby";
            System.out.println("Person() run...");
        }
    
        Person(String name)
        {
            this.name = name;//局部变量和成员变量重名了。
            System.out.println("person(name)...run...");
        }
    
        Person(String name,int age)
        {
            this.name = name;
            this.age = age;
            System.out.println("person(n,a)....run....");
        }
    
        public void show()
        {
            
            System.out.println(this.name+"...."+this.age);
        }
    
        public void method(int x)
        {
            this.show();
        }
    }
    
    
    
    class ThisDemo 
    {
        public static void main(String[] args) 
        {
            Person p = new Person("李四");
            p.show();
            Person p1 = new Person("王武");
            p1.method();
    
        }
    }
    /*
    this关键字的用法二:
    构造函数间调用。this关键字。
    用法格式:this(对应的实参列表);
    注意:必须定义在构造函数的第一行,因为初始化动作要先执行。
    
    构造间调用其实也是为了初始化的复用性。
    
    不要出现互相调用,产生递归,容易栈溢出。
    */
    
    class Person
    {
        private String name;
        private int age;
    
        Person()
        {
            
            this.name = "baby";
            System.out.println("Person() run...");
        }
    
        Person(String name)
        {
        
            this.name = name;
            System.out.println("person(name)...run...");
        }
    
        Person(String name,int age)
        {
            this(name);//用于调用构造函数。注意:调用构造函数的语句必须定义在构造函数的第一行!
            
            this.age = age;
    
            System.out.println("person(n,a)....run....");
    
        
        }
    
        public void show()
        {
            
            System.out.println(this.name+"...."+this.age);
        }
        public void method()
        {
            this.show();
        }
    }
    
    
    
    class ThisDemo2 
    {
        public static void main(String[] args) 
        {
            Person p = new Person("李四",20);
            new Person();
        }
    }
    /*
    this在代码中的应用。
    */
    class Person
    {
        private int age;
        Person(int age)
        {
            this.age = age;
        }
    
        /*
        定义一个功能,判断和别人是否是同龄人。
        结果?boolean
        参数?Person
    
        功能内部如果用到了调用该功能的对象,用this代表这个对象。
        */blic boolean equalsAge(Person p)
        
        pu{
            return this.age == p.age;
        }
    }
    
    
    class ThisDemo3 
    {
        public static void main(String[] args) 
        {
            Person p1 = new Person(32);
            Person p2 = new Person(23);
            boolean b = p1.equalsAge(p2);
            System.out.println("b="+b);
        }
    }

     

    3、static关键字

    /*
    static 关键字是一个成员修饰符。
    
    static关键字的特点:
    1,静态的数据被对象所共享。
    2,它优先于对象加载并存在。
        随着类的加载而加载。
    3,静态的数据多了一种调用方式:可以直接被类名所调用。
    
    
    既然静态调用这么方便,是不是可以让所有的成员变量变成静态的呢?
    不行,因为数据中有些是对象共享的数据需要静态化,节省内存空间,严谨。
    有些数据是对象特有的数据,这些存储到对象中。
    这也是成员变量是否要静态的依据!
    
    
    举例:教室里的饮水机和每个对象特有的杯子的故事!
    
    
    
    静态变量和成员变量的区别?
    
    名称(所属):
    静态变量所属于类,也称为 类变量。
    成员变量所属于对象,也称为 实例变量。
    
    内存位置:
    静态变量存储于方法区中的静态区中。
    成员变量存储于堆内存的对象中。
    
    加载先后:
    静态变量随着类的加载而加载,随着类的消失而消失。
    成员变量随着对象的加载而加载,随着对象的消失而消失。
    
    
    
    
    
    
    */
    class Person
    {
        String name;
        static String country = "cn";
    }
    
    
    class StaticDemo 
    {
        public static void main(String[] args) 
        {
            Person p = new Person();
            p.name = "lisi";
            
            //静态的成员的调用。
            System.out.println(Person.country);
        }
    }
    /*
    静态方法:
    1,静态方法只能访问静态成员,不能直接访问非静态成员。
        非静态的方法可以访问静态和非静态。
        其实原因就是加载的先后顺序问题。先加载的不能访问后加载。
    2,静态方法中不可以出现this,super关键字。
    
    
    什么时候方法静态?
    方法中如果没有访问对象的特有数据,或者说没有调用过非静态的内容。
    该方法就静态化。虽然不静态也可以使用,但是创建调用它的对象没有意义。
    
    
    */
    class Person
    {
        String name;
        static String country = "cn";
    
        static void show()
        {
    //        System.out.println(this.name);//编译失败。
            System.out.println(country);
        }
    
        static void method()
        {
            System.out.println(Person.country);
        }
    }
    
    class StaticDemo2 
    {
        public static void main(String[] args) 
        {
    //        new Person().show();
    //        Person.show();
    //        new Person().method();
            Person.method();
        }
    }

     

    4、main方法

    /*
    
    public static void main(String[] args) 
    public : 权限修饰符,主方法的权限最大。
    static : 随着类的加载而加载,直接被类名调用。
    void : 主方法没有具体的返回值。
    main : 方法名称,不是关键字,但是该名字固定。
    String[] args : 方法的参数列表,一个字符串数组参数。args就是变量名。
    
    */
    
    class MainDemo 
    {
        int x = 4;
        public static void main(String[] args) //args = new String[0];
        {
            /*
            System.out.println(args.length);//[Ljava.lang.String;@19836ed
            
            for(int x=0; x<args.length; x++)
            {
                System.out.println(args[x]);
            }
            */
    
            new MainDemo().show();
        }
    
        void show()
        {
            System.out.println(x);
        }
    }

     

    5、静态代码块

    /*
    静态代码块。
    特点:随着类的加载而执行,而且只执行一次。
    作用:用来给类进行初始化的。
    
    */
    
    class StaticCode
    {
    //    static int x= 3;
        static 
        {
    //        x = 5;
            System.out.println("a");
        }
        static void show()
        {
            System.out.println("show run");
        }
    }
    
    class  StaticCodeDemo
    {
        static 
        {
            System.out.println("b");
        }
        public static void main(String[] args) 
        {
            StaticCode.show();
        }
        static 
        {
            System.out.println("c");
        }
    }

     

    6、对象的初始化过程

     

    7、小练习

    A、

    class Person
    {
        private String name = "baby";
    
        {//构造代码块作用,给所有的对象初始化。
            System.out.println("code......"+this.name);
            cry();
        }
    
        Person()//构造函数只给对应的对象初始化。
        {
    //        cry();
            System.out.println("person() run....");
        }
        Person(String name)
        {
            this.name = name;
    //        cry();
            System.out.println("person(name) run......");
        }
    
        void cry()
        {
            System.out.println("哇哇......");
        }
    
    }
    
    
    class CodeDemo 
    {
        public static void main(String[] args) 
        {
            Person p = new Person();
            Person p1 = new Person("lisi");
    
            {//局部代码块。控制局部变量的生命周期。
                int x = 4;
    
                System.out.println("x="+x);
    
            }
                System.out.println("x="+x);
    
            System.out.println("over");
        }
    }

    B、

    /*
    综合练习,练习一下之前的小知识点。
    
    主函数定义代码--->封装到函数中提高复用性---->将函数封装到对象中。
    
    
    */
    class ArrayToolDemo 
    {
        public static void main(String[] args) 
        {
    
            int[] arr = {34,120,78,45,90,33};
            
            int max = ArrayTool.getMax(arr);
            int min = ArrayTool.getMin(arr);
            
            
            System.out.println("max="+max);
            System.out.println("min="+min);
        }
        
        
    }

    C、

    /**
    这是一个用于操作数组的工具类,功能有获取最值,排序等一系列静态方法。
    
    @author 张三
    @version V1.0
    
    
    */
    
    public class ArrayTool
    {
        /**
        构造函数。
        */
        public ArrayTool(){}
    
        /**
        获取数组的最大值。
        @param arr 接收的是一个int类型的数组。
        @return 返回该数组的最大值。
        */
        public static int getMax(int[] arr)
        {
            int max = arr[0];
            for(int x=1; x<arr.length; x++)
            {
                if(arr[x]>max)
                    max = arr[x];
            }
            return max;
        }
    
        /**
        获取数组的最小值。
        @param arr 接收的是一个int类型的数组。
        @return 返回该数组的最小值。
        */
        public static int getMin(int[] arr)
        {
            int min = arr[0];
            for(int x=1; x<arr.length; x++)
            {
                if(arr[x]<min)
                    min = arr[x];
            }
            return min;
        }
        /**
        对整型数组进行从小到大的排序。
        @param arr 接收的是一个int类型的数组。
        */
        public static void selectSort(int[] arr)
        {
            for (int x=0; x<arr.length-1 ;x++ )
            {
                for (int y=x+1; y<arr.length ;y++ )
                {
                    if(arr[x]>arr[y])
                    {
                        swap(arr,x,y);
                    }
                }
            }
        }
        /**
        对数组中的两个位置的元素进行置换。
        @param arr 接收的是一个int类型的数组。
        @param a 需要置换的元素的角标
        @param b 需要置换的另一个元素的角标
        */
        private static void swap(int[] arr,int a,int b)
        {
            int temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }
    }

     

    本博客所有文章如无特别注明均为原创。
    复制或转载请以超链接形式注明转自Who am I ?,原文地址《Day5:面向对象的定义(中)
    标签:
    喜欢 | 0
    分享:

还没有人抢沙发呢~