JAVA 面向对象一

leiHanc

于 2017-02-20 13:44:52 发布

阅读量355

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/leiHanc/article/details/56012068

版权

JAVA 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

面向对象

面向对象是一种思想，将事情简单化，由执行者转化为指挥者

特征：封装，继承，多态

类和对象的关系

类就是对现实生活中事物的描述

对象是这类事物中实实在在存在的个体

想要描述：提取对象中共性内容。对具体的抽象。映射到Java中描述就是class定义的类。

描述事物就是在描述事物的属性和行为，属性和行为共同成为类中的成员。

创建对象就是在堆内存中产生一个实体。

成员变量和局部变量

成员变量作用于整个类中，局部变量作用于函数中或语句中。

成员变量存在于堆内存中，因为对象的存在才在内存中存在，局部变量在栈内存中

成员变量随着对象的创建而存在，随着对象的消失而消失，局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
成员变量都有默认初始化值，局部变量没有默认初始化值。

函数

函数就是定义在类中的具有特定功能的小程序，也称为方法

函数的格式

修饰符返回值类型函数名（参数类型，形式参数）{

函数体；

}
主函数
public ：代表该访问权限是最大的
static：代表主函数随着类的加载已经存
void：主函数没有具体的返回值
main：不是关键字，但是是一个特殊发单词，可以被jvm识别
String[ ] args ：函数的参数，参数类型是一个数组，该数组的元素是一个字符串，居jvm在调用时传入的是new String[0]

如何定义一个函数

（1）先明确该功能的运算结果（明确返回值类型）

（2）再明确在定义该功能的过程中，是否需要未知的内容参与运算（明确该参数类型和个数）

重载：方法名相同，但参数个数及顺序，数据类型不同

什么时候用重载

当定义的功能相同，但参与运算的未知内容不同，那么这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名参数，重载和返回值类型没有关系。

构造函数：可以用于给对应的对象进行初始化

当一个类中没有定义构造函数时，系统会，默认先给该类加入一个空参的构造函数

当在类中定义了构造函数后，默认的构造函数就没有了。

构造函数特点
函数名与类名相同
不用定义返回值类型
没有具体的返回值。

构造函数和一般函数的区别

构造函数在对象已建立就运行，给对象初始化。一般方法是对象调用才执行，给对象添加具备的功能。

一个对象建立，构造函数只执行一次。而一般方法可以被对象调用多次

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

构造代码块：给所有的对象就行初始化{}

对象已建立就运行，优先于构造函数执行，构造代码块定义的是不同对象的共性内容。

权限修饰符

权限由大到小

public--->protected--->friendly--->private

public可以修饰类，数据成员，构造方法，方法成员。被public修饰的成员，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符

protected可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。被protected修饰的成员，能在定义它们的类中，同包的类中被调用。如果有不同包的类想调用它们，那么这个类必须是定义它们的类的子类

friendly可以修饰类，数据成员，构造方法，方法成员，都能够使用默认权限，即不写任何关键字。默认权限即同包权限，同包权限的元素只能在定义它们的类中，以及同包的类中被调用。非同包中继承也不行

private可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。被private修饰的成员，只能在定义它们的类中使用，在其他类中不能调用

常见规则如下：

所有的类都用public修饰。并且，在一个java文件中，只写一个类。
所有的成员变量用private修饰。
所有的成员方法用public修饰。
如果是抽象类或者接口：public abstract + …
所有的构造方法用public修饰。
如果类是工具类或者单例类：构造用private修饰

创建对象

     /*
    类和对象的关系
    现实生活中的对象：张三，王五
    想要描述：提取对象中共性内容，对具体的抽象，描述时，这些对象的共性是（姓名，年龄，性别）
    映射到java中，描述就是class定义的类。  
    具体对象就是对应java在堆内存中用new建立实体。   
    类就是：对现实生活中事物的描述。  
    对象：就是这类事物，实实在在存在个体。  
      
    */  
      
    //需求：描述汽车(颜色，轮胎数)。描述事物其实就是在描述事物的属性和行为。  
      
    //属性对应是类中变量，行为对应的类中的函数(方法)。  
    //其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。  
      
    
    class Car  
    {  
        //描述颜色  
        String color = "红色";  
        //描述轮胎数  
        int num = 4;  
      
        //运行行为。  
        void run()  
        {  
      
            System.out.println(color+".."+num);  
        }  
          
    }  
      
      
    class  CarDemo  
    {  
        public static void main(String[] args)   
        {  
            //生产汽车。在java中通过new操作符来完成。  
            //其实就是在堆内存产生一个实体。  
            //Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。  
      
            //需求：将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是：对象.对象成员  
            //c.color = "blue";  
              
            //c.run();  
      
            //Car c1 = new Car();  
            //c1.run();//red 4;  
      
      
    //      Car c = new Car();  
    //      c.num = 5;  
            /* 
            new Car().num = 5; 
            new Car().color = "blue"; 
            new Car().run(); 
     
            Car c = new Car(); 
            c.run(); 
            c.num = 4; 
            new Car().run(); 
            */  
            //匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。  
            //如果对一个对象进行多个成员调用，必须给这个对象起个名字。  
            //匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。  
      
      
            Car q = new Car();  
            show(q);  
      
            //show(new Car());  
        }  
      
        //需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。  
        public static void show(Car c)  
        {  
            c.num = 3;  
            c.color = "black";  
            c.run();  
        }  
    }

封装
封装：是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
优点：
*将变化隔离
*便于使用
*提高重用性
*提高安全性
封装原则：
*将不需要对外提供的内容都隐藏起来
*把属性都隐藏，提供公共方法对其访问。
private（私有）关键字
*是一个权限修饰符。
*用于修饰成员（成员变量和成员函数）。
*被私有化的成员仅在本类中有效。
常用之一：将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高数据访问的安全性。

/* 
private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。 
私有只在本类中有效。 
 
将age私有化以后，类以外即使建立了对象也不能直接访问。 
但是人应该有年龄，就需要在Person类中提供对应访问age的方式。 
 
注意：私有仅仅是封装的一种表现形式。 
 
 
之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。 
对访问的数据进行操作。提高代码健壮性。 
 
*/  
public class Student {
    private String name;
    private int age;
    private byte sex;
    
    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 < 0 || age > 100){
            this.age = -1;
        }else{
            this.age = age;
        }
    }

this关键字的应用及在构造函数中的调用
this关键字特点：this代表其所在函数所属对象的引用。换言之-----this代表本类对象的引用。
什么时候用this关键字呢？
1.用于区分同名变量的情况（成员变量和局部变量同名的时候）
2.用于构造函数间的调用

总之当在函数内需要用到调用该函数的对象时，就用this

    /* 
    this:看上去，是用于区分局部变量和成员变量同名情况。 
    this为什么可以解决这个问题？ 
    this到底代表的是什么呢？ 
     
    this：就代表本类的对象，到底代表哪一个呢？ 
        this代表它所在函数所属对象的引用。 
        简单说：哪个对象在调用this所在的函数，this就代表哪个对象。 
     
     
    this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。 
            但凡本类功能内部使用了了本类对象，都用this表示。 
     
    */  
      
    class Person  
    {  
        private String name;  
        private int age;  
        Person(int age)  
        {  
            this.age = age;  
        }  
        Person(String name)  
        {  
            this.name = name;  
        }  
        Person(String name,int age)  
        {  
            this.name = name;  
            this.age = age;  
        }  
      
        public void speak()  
        {  
            System.out.println("name="+this.name+"...age="+this.age);  
            this.show();  
        }  
        public void show()  
        {  
            System.out.println(this.name);  
        }  
      
        /* 
        需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。 
        */  
        public boolean compare(Person p)  
        {  
            return this.age==p.age;  
      
        }  
    }  
      
    class PersonDemo3   
    {  
        public static void main(String[] args)   
        {  
      
            Person p1 = new Person(20);  
            Person p2 = new Person(25);  
            boolean b = p1.compare(p2);  
            System.out.println(b);  
      
      
            //Person p = new Person("lisi");  
            //Person p1 = new Person("zhangsan");  
            //p.speak();  
            //p1.speak();  
            //p.speak();  
        }  
    }

    /* 
    this语句 :用于构造函数之间进行互相调用。 
     
    this语句只能定义在构造函数的第一行。因为初始化要先执行。 
    */  
      
    class Person  
    {  
        private String name;  
        private int age;  
          
        {  
              
            System.out.println("code run");  
        }  
          
        Person()  
        {  
            //this("hah");  
            System.out.println("person run");  
        }  
        Person(String name)  
        {  
            //this();  
            this.name =name;  
        }  
        Person(String name,int age)  
        {  
            //this(name);  
            //this.name = name;  
            this.age = age;  
              
        }  
      
    }  
      
    class  PersonDemo4  
    {  
        public static void main(String[] args)   
        {  
            new Person();  
            //Person p = new Person("lisi",30);  
            //Person p1 = new Person("lisi2",36);  
      
        }  
    }