Java——类（面向对象篇）

面向对象

类的创建

对某一类事物共性的抽象，标准，模板。
创建一个类：
例：

public class Cook{
}

对象的创建

例：

Cook cook=new Cook();

构造器（构造方法）

①方法名和 类名相同。
②在方法名的前面没有返回值类型的声明。
③在方法中不能使用return语句返回一个值。
④在创建（new）对象时，同时也会调用这个对象的无参构造方法。
例：

Cook cook=new Cook();

⑤当没有指定的构造方法，创建对象时系统会自动添加一个无参的构造方法。
⑥当有指定构造方法时，系统将不再自动添加无参的构造方法。
⑦构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的构造方法。

无参构造方法

class person{
　　public person(){
			//定义的无参构造方法
　　　　System.out.println("无参的构造方法被调用了。。。");
　　}
}
	//重新创建定义一个测试类
class Ex11{
	//测试类的程序入口
　　public static void main(String[] args){
　　	//创建一个person对象，同时调用person类中的无参构造方法
　　　　　person p=new person();
　　}
}

 

有参的构造方法（目的就是为了给对象实例变量赋值）

class person{
	//定义成员属性
　　int age;
	//定义有参构造方法
　　public person(int a){
　　　　age=a;
}
	//定义的普通方法
　　public void speak(){
　　　　System.out.println("I am "+age+" years old");
　　}
}
	//重新创建定义一个测试类
class Ex11{
	//方法的程序入口
　　public static void main(String[] args){
		//创建new一个person对象
　　　　person p=new person();
　　　　//调用对象里面的speak方法
　　　　p.speak();
　　}
}

普通方法： 有返回类型，方法名小写，不能和类名相同。

构造方法： 是初始化对象的重要途径。创建一个对象对象的同时，并可初始化对象的值。
注意： 普通方法用来定义对象的功能行为，构造方法用来初始化。

this关键字（两个用途）

当成员变量与局部变量同名时，用来区分成员变量和局部变量（形参）、
区分同名的属性和局部变量，在构造函数中调用构造函数。
例：

public class Person {
    private String name;
    private int age;
    //空构造器
    public Person(){
        System.out.println("我是无参构造器");
    }
    public Person(String name,int age){
        //调用无参构造器
        this();
        //区分成员变量与局部变量，指当前对象
        this.name=name;
        this.age=age;
        System.out.println("我是有参构造方法");
    }
}

static关键字（静态）

属性（静态属性）： 跟随类存在，在创建对象之前就可以直接访问（直接调用），调用不依赖任何的对象；静态属性是属于类的，不属于任何一个对象，所有的对象可共用一份属性。
方法（静态方法）： 跟随类存在，在创建对象之前就可以直接访问（直接调用），调用不依赖任何的对象对于静态的内容（属性、方法）。
可以通过对象的方式去访问，也可以通过类的方式访问，但是推荐使用类的方式直接调用。
注意: 对于非静态的内容，只能通过对象访问。在静态的方法中，不能访问非静态的内容，反之在非静态方法中是可以访问静态内容。

封装

package与import

package(包): 包本质是文件夹，包名 如：com.baidu.oop。
包的声明：类文件的第一行，类体的外部；包的声明和类所在的路径必须要一致，一般自动生成。
import：

访问权限

关键字

            
            public	  protected	 default	private
同一个类中	  √	         √	       √	      √
同一个包中	  √	         √	       √
子类中		  √	         √ 
全局范围内	  √

PO：Javabean

JavaBean
就是普通的java类，一般用来存储数据信息的，提供最基本的信息（属性），按需提供构造器（一般会显示给出无参构造），提供属性的设定器（setter）和访问器（getter）。设定器和访问器也就是普通的方法，只是通常都只用来为属性设定值和获取值，则为了方便取了别名叫setter和getter，但是随着大家的习惯和约定，设定器和访问器已经有了自己固定的写法（后期很多时候大家都按照这种约定）set+属性名首字母大写；get +属性名首字母大写在编写 javabean 中的有一些常用的规则如: 1)、属性尽可能私有化 private 2)、设定器 setter 与 getter 访问器 ，一般 public 居多。
例：

public class Teacher {
    private String name;
    private boolean sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

继承

①子类拥有父类非 private 的属性、方法。

②子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

③子类可以用自己的方式实现父类的方法。

④Java 的继承是单继承，但是可以多重继承，

⑤提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承关键字（extends、 implements）

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
子类（派生类）
父类（基类、超类）

super

super关键字： 我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！当子类继承的父类的功能不能达到实现预期的目的或根据自己的需要重新定义。
例：

public class Students {
  	//定义一个方法
    public void Name() {
        System.out.println("我是白色的");
    }
}
	//Worker类继承Students类
public class Worker extends Students {
	public void Name(){
            System.out.println("我是红色的");
        }
    }
    //测试类
public class Test{
	public static void main(String[] args){
	Stutends ear=new Worker();
	ear.Name;
	//运行结果为我是红色的
	}
}

Object继承链

Object 类是所有 Java 类的根基类 ;如果一个类没有显示继承任何类，那么它的父类就是Object类；
如果在类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类。

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。

//声明类
	final class 类名{类体}
//声明方法
	访问修饰符 final 返回值类型 方法名(){方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动声明为 final，但是实例变量并不是 final。

引用和对象

创建对象，系统做的事情：

1、根据模板取堆中开辟空间，并且给所有非静态属性默认值

2、调用构造器初始化属性

3、返回开辟的空间的首地址