编程中的“对象”，你了解多少？

Java作为一种面向对象语言。

支持以下基本概念：

多态

继承

封装

抽象

类

对象

实例

方法

重载

对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

类：类是一个模板，它描述一类对象的行为和状态。

对象的创建

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

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

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

类的使用

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

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();

}

}

构造方法

构造方法的名称必须与类的名称相同，并且没有返回值。

每个类都有构造方法。如果没有显式地为类定义构造方法，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();

}

}

控制类、属性和方法的访问权限

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;//默认的

}

变量的作用域

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

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

System.out.println("局部变量，在可以在局部进行使用"+i);

}

}

}

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);

}

}

JAVA中方法的重载

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

}

}

包装类（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);

}

}

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

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

继承

重写

父类引用指向子类对象

源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

一个源文件中只能有一个public类

一个源文件可以有多个非public类

源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。

如果一个类定义在某个包中，那么package语句应该在源文件的首行。

如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。

import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。