java-面向对象（上）

1.概述

封装：将对象的属性和行为封装起来；
继承：描述类与类之间的关系，对原有类的功能进行扩展
多态：一个类中定义的属性和功能被其他类继承后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法所呈现出的多种不同的行为特性

类：对某一类事物的抽象描述
对象：现实中某一类事物的个体
类的定义：

[修饰符] class [extends 父类名] [implements 接口名]{
	//类体，包括类的成员变量和成员方法
	//声明成员变量
	[修饰符] 数据类型 变量名[=值];//修饰符可以是public或者private
	//声明成员方法
	[修饰符] [返回值类型] 方法名[参数类型 参数名，……]{
	//具体方法
	return 返回值;
	}
}
/*修饰符可以是public也可以不写；类名的首字母要大写*/
//例子
public class Persion {
    int age=10;
    void speak(){
        System.out.println(age);
    }
}

对象的定义：

类名 对象名称=new 类名();
//例子
Persion p=new Persion();

访问控制级别：
private：类成员只能被同一类访问；
default：可以被同一类，或者同一包成员访问；
protected：可以被同一类、同一包、该类的子类访问；
public：都可以访问；
注：源文件的名称必须与public类的名称相同

2.封装

实现：将类中的属性私有化，并提供使用public访问的公有方法

private int age;
int getAge(){
	this.age=age;
	return age;
}
void setAge(int a){
	if(a>0){
		this.age=a;
	}
	else{
		System.out.println("error!");
	}
}

3.方法的重载

java允许在一个程序中定义多个名称相同但参数的类型或个数不同的方法。

public static int add(int x1,int x2,int x3){
	return x1+x2+x3;
}
public static int add(int x1,int x2){
	return x1+x2;
}
public static double add(double x1,double x2,double x3){
	return x1+x2+x3;
}

4.方法的递归

指在一个方法内部调用自身。递归需要有结束条件。

public static int getsun(int n){
	if(n==1){
		return 1;
	}
	int temp=getsum(n-1)
	return temp+n;
}

5.构造方法

在实例化对象的同时为这个对象的属性进行赋值。
构造方法也可以看做是类的一个特殊成员，在实例化对象时被自动调用。
构造方法需要满足的条件：
（1）方法名与类名相同
（2）在方法名的前面没有返回值类型的声明
（3）在方法中不能使用return语句返回一个值，但可以单独写return语句作为方法的结束
构造方法示例：

class Persion{
	int age;
	public Persion(int a){
		age=a;
	}
}
public class Example{
	Persion p=new Persion(18);
}

注：构造方法也可以重载

6.关键字

（1）this关键字
1）通过this关键字调用成员变量，解决与局部变量的名称冲突问题

class Persion{
	int age;
	public Perdion(int age){
		this.age=age;//this.age指代的是Persion类的成员变量
	}
}

2）通过this关键字调用成员方法（此处的this也可以省略不写）

class Persion{
	public void add(){
	}
	public void add2(){
		this.add();
	}
}

3）通过this关键字来调用构造方法。可以在构造方法（不能在成员方法中）中使用this（只能在该方法的第一条语句且只能出现一次）来调用其他的构造方法。

class Persion{
	public Persion(){
	}
	public Persion(int age){
		this();//调用上面无参的构造函数
	}
}

注：不能在一个类的两个构造方法中使用this相互调用。
（2）static关键字
静态变量：开发人员希望特定的数据在内存中只有一份并且能够被一个类的所有实例对象共享。

class Persion{
	static int age=18;
}
//基于类Persion创造的所有对象都具有age=18成员变量

静态方法：开发人员希望在不创建对象的前提下就可以调用某一方法。（静态方法也可以实例化之后再调用）

class Persion{
	public static void speak(){
		System.out.println("hello world!");
	}
}
public class Example{
	Persion.speak();//调用静态方法
}

静态代码块：当类被加载时，静态代码块会实行，由于类只加载一次，因此静态代码块也只执行一次。通常使用静态代码块对类中的成员变量进行初始化。

class Persion{
	static{
		System.out.println("hello!");
	}
}

7.例子

package com.csh.helloworld;
class Student{
    int age;
    String name;//student类中包含age和name两个属性
    public int getAge(){
        return age;
    }
    public void setAge(int a){
        age=a;
    }
    public String getName(){
        return name;
    }
    public void setName(String a){
        name=a;
    }
    public Student(){

    }//构造方法
    public Student(int age,String name){
        this.age=age;
        this.name=name;
    }//构造方法重载
}
public class Chapter3_1 {
    public static void main(String[] args) {
        Student s1=new Student();//创建对象
        //调用方法赋值
        s1.setAge(18);
        int x=s1.getAge();
        System.out.println("the student's age:"+x);
        s1.setName("wang");
        String y=s1.getName();
        System.out.println("the student's name:"+y);

        //调用构造方法赋值
        Student s2=new Student(30,"zhang");
        int x1=s2.getAge();
        System.out.println("the student's age:"+x1);
        String y1=s2.getName();
        System.out.println("the student's name:"+y1);
    }
}

//使用递归求斐波那契数列第n个数的数值
package com.csh.helloworld;

public class Chapter3_2 {
    public static int sum(int n){
        if(n==1){
            return 0;
        }
        if(n==2){
            return 1;
        }
        return sum(n-1)+sum(n-2);
    }

    public static void main(String[] args) {
        int a=sum(7);
        System.out.println(a);
    }
}