JAVA编程中的类和对象

1：初学JAVA，都知道JAVA是面向对象的编程。笔者这节开始说说类和对象。（实例仅供参考，如若复制粘贴记得修改包名和类名，避免出错）

学习JAVA的快捷键，Alt+/代码补全功能，其实此快捷键启动了Eclipse代码辅助菜单，Shift+Ctrl+o快捷键导入包

Ctrl+F可以快速查找API,中文版API,百度云链接：http://pan.baidu.com/s/1slQWhCL 密码：cfxo

首先

对象的创建：类名  对象名=new 类名();也许大多数学习java的都会写，但是理解方面是这样的，

new一个类名，就会得到一个对象，而这个对象的类型就是这个类名的类型

比如说：Car car=new Car();//就是通过new一个Car类名，得到car这个对象，而这个对象就是Car类型的

2:类必须先定义才能使用。类是创建对象的模板，创建对象也叫类的实例化。

package com.cnblogs;//定义包的格式，关键词package,包的名字最规范的格式是域名的反写，比如com.什么

public class People {//class关键字，定义类的关键字，People是类的名称
    
    public String name;//类的属性
    public String sex;
    public int age;

　//类的方法　
    public void sleep(){
        System.out.println("人疲倦的时候喜欢睡觉觉");
    }
    
    public void eat(){
        System.out.println("人饥饿的时候喜欢吃饭饭");
    }
    public static void main(String[] args) {//主函数
        People p=new People();//对象的实例化
        p.eat();//调用类的方法
        p.sleep();
    }

}
3：构造方法

构造方法的名称必须与类的名称相同，并且没有返回值。
每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的构造方法。

package com.cnblogs;

public class People {
    
    public String name;
    public String sex;
    public int age;
    
    public People(){//默认的构造方法，初始化对象的时候调用默认构造方法
        System.out.println("类默认的构造方法,不含参数");
    }
    public People(String name){//含参的构造方法
        System.out.println("含参的构造方法");
    }
    public void sleep(){
        System.out.println("人疲倦的时候喜欢睡觉觉");
    }
    
    public void eat(){
        System.out.println("人饥饿的时候喜欢吃饭饭");
    }
    public static void main(String[] args) {
        People p=new People();
        p.eat();
        p.sleep();
    }
    
}

4：Java 通过修饰符来控制类、属性和方法的访问权限和其他功能，通常放在语句的最前端。

权限(访问)修饰符关键字包含：public ,private ,protected，另外一个就是默认的;

public:对所有类可见，包含本类，同包其他类或者子类，其他包的类或者子类

protected:对本类可见，对同包其他类或者子类可见，对其他包的类或者子类不可以见

private:只对本类可见，对同包其他类或者子类不可见，对其他包的类或者子类不可以见

默认：则是对同一包内可见

实例如下：

package com.cnblogs;

public class Men {
    
    public String name;//共有属性
    private int age;//私有属性
    protected String sex;//受保护的属性
    int a=10;//默认的
}

5：变量的作用域，包含全部变量和局部变量

举例如下

package com.cnblogs;

public class Men {
    //全部变量，在整个作用域都可以使用
    public String name;//共有属性
    private int age;//私有属性
    protected String sex;//受保护的属性
    int a=10;
    public static void main(String[] args) {
        //定义的i是局部变量，只可以在for循环这个局部内进行使用
        for(int i=0;i<10;i++){
            System.out.println("局部变量，在可以在局部进行使用"+i);
        }
    }
    
}

6：this关键字

this 关键字用来表示当前对象本身，或当前类的一个实例，通过 this 可以调用本对象的所有方法和属性。

成员变量与方法内部的变量重名时，希望在方法内部调用成员变量，怎么办呢？这时候只能使用this。

作为方法名来初始化对象，也就是相当于调用本类的其它构造方法，它必须作为构造方法的第一句。

作为参数传递，需要在某些完全分离的类中调用一个方法，并将当前对象的一个引用作为参数传递时。

举例如下

package com.cnblogs;

public class Dog {
    
    int a=21;
    int b=12;
    
    public Dog(){//this关键字作为方法名来初始化对象
        this(23,43);
    }
    
    public Dog(int a, int b) {
        // TODO Auto-generated constructor stub
        this.a=a;
        this.b=b;
        System.out.println(a+" "+b);
    }

public void add(){//通过this关键字可以调用类的属性和方法
        int c=this.a+this.b;
        System.out.println(c);
    }
    
    public void setA(int a){//使用this关键字区分同名变量
        this.a=a;
    }
    public int getA(){
        return a;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Dog d=new Dog();
        d.add();
        
        d.setA(44);
        int dd=d.getA();
        System.out.println(dd);
    }

}
7：JAVA中方法的重载（构造方法也可以重载）

即方法的名字相同，而方法的参数类型，个数，顺序不同即为方法的重载

注意1：声明为final的方法不可以重载，声明为static的方法不能被重载，但是能够被再次声明。

注意2：仅仅是返回值类型不同，不能构成方法的重载

举例如下：

package com.cnblogs;

public class Cat {
    
    public void cat(){
        System.out.println("方法的重载");
    }
    public void cat(int a,int b){
        System.out.println("方法的重载，方法中参数的个数");
    }
    public void cat(String c,int d){
        System.out.println("方法的重载，方法中参数的类型不同");
    }
    public void  cat(int e,String f){
        System.out.println("方法的重载，方法中参数顺序不同");
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
    }

}

8：包装类（Wrapper Classes），拆箱和装箱

基本类型和对应的包装类可以相互装换：

由基本类型向对应的包装类转换称为装箱，例如把double包装成 Double 类的对象；

包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。

package com.cnblogs;

public class Sun {

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a=32;
        Integer i=new Integer(a);
        System.out.println("手动进行装箱"+i);
        
        int a2=i.intValue();//此方法的作用是以int值返回此Integer对象
        System.out.println("手动进行拆箱"+a2);

　　　int a4=54;
        Integer i4=a4;//自动装箱
        System.out.println("自动进行装箱"+i4);
    }

}

重点笔记，加强理解多态的含义

多态存在的三个必要条件:

• 继承
• 重写
• 父类引用指向子类对象