javaWeb以及spring学习需要掌握面向对象的知识:上篇

1.private 修饰符 *

1.1为什么要实现封装 

其目的是将对象中的属性和方法组织起来。同时隐藏不想暴露的属性和方法及实现细节。

1.2 怎么实现封装

第一步：属性私有化（使用private关键字将类中的属性进行修饰。）

第二步：如果外界想要访问私有属性，就需要提供get、set方法，外部程序只能通过set方法修改，只能通过get方法读。(提供get、set方法)

1.3 封装与不封装的区别

属性封装之前，外界可以随意的访问修改。

属性封装之后，外界只可以通过get、set方法访问修改

public class dog {
    //不封装属性
	int age;
	String name;

    //封装属性
	private int age; 
	private String name;
    //提供get、set方法供外界使用
    public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
    
}
public class demo {
	public static void main(String[] args) {
          //实列化,要想使用类中的属性，需要实列化才可以调用
	      dog dog = new dog();	
          //属性不封装，外界可以随意赋值
	      System.out.println(dog.age = 10);  //输出10

          //属性封装,外界不可以赋值，需要通过set方法赋值，get方法读取
          System.out.println(dog.age = 10);  //报错
          //使用set方法赋值
          dogs.setAge(10);
          //使用get方法读取
	      System.out.println(dogs.getAge()); //输出10
	}
}

2.this关键字

2.1 通过this关键字调用成员变量

public class thiss {
     int age;
     public thiss(int age) {  //有参构造方法，没有返回值，名字和类名一样
    	 this.age = age;  //将局部变量age的值赋值给成员变量
     }
     public static void main(String[] args) {
		thiss t = new thiss(999); //给有参构造方法传值
		System.out.println(t.age); //输出999
	}
}

2.2 通过this关键字调用成员方法

public class thiss {
     public void name() {
		System.out.print("我是傅");
	}
     public void age() {
    	//调用name方法
		this.name();
		System.out.println("，我今年19岁");
	}
    public static void main(String[] args) {
    	//要想使用类中的属性，需要实列化
		thiss thiss = new thiss();
		thiss.age(); //输出我是傅，我今年19岁
	}
}

2.3 通过this关键字调用构造方法

public class thiss {
    
    public thiss() {
		System.out.print("我是无参构造方法，");
	}
    public thiss(int age) {
    	this(); //调用无参构造方法
		System.out.println("我是有参构造方法");
	}
	public static void main(String[] args) {
    	//要想使用类中的属性，需要实列化
		thiss thiss = new thiss(19);
		System.out.println(thiss); //输出我是无参构造方法，我是有参构造方法，task1.thiss@b4c966a
	}
}

3.类的继承

3.1 什么是继承

继承是指在一个现有的类的基础上去创建一个新的类，创建出来的新类被称为子类，现有类被称为父类，子类会自动继承父类所有可以继承的属性和方法。

3.2 语法及示例

[修饰符] class 子类名 extends 父类名 {
   //程序核心代码
}

public class Animal{
	String name;
	void show() {
		System.out.println("叫!");
	}
}

public class Dog extends Animal{
     public static void main(String[] args) {
    	    Dog dog = new Dog();
    	    dog.name = "狗";
    	    System.out.print(dog.name);
    	    dog.show(); //输出狗叫！
	}
}

3.3  方法重写

字类会自动继承父类中公共的方法，但有时在子类中需要对继承的方法进行一些修改，即对类的方法进行重写。需要注意的是（类中重写的方法需要和父类重写的方法具有相同的方法名、参数列表以及返回值类型）

public class Animal{
	String name;
	//定义动物叫的方法
	void show() {
		System.out.println("叫!");
	}
}

//继承分类Animal的属性
public class Dog extends Animal{
 
	//在eclipse中： alt+shift+s选择Override ...进行方法重写
	@Override   //@Override 强制检查方法是否是重写的方法
	//定义狗叫的方法
	void show() {
		System.out.println("狗叫");
	}
	int age;
	//为什么要写main方法，有main方法才可以测试输出
    public static void main(String[] args) {
    	//可以怎么讲，想要使用main方法外面的属性，就要实例化
		Dog dog = new Dog();
		dog.show(); //输出狗叫
	}
}

3.4 super关键字

子类对象重写父类方法后，子类对象将无法直接访问父类被重写的方法，为了解决这个问题，在java中专门提供了一个supper关键字来访问父类的成员变量、成员方法、构造方法。

注意: 不可以在静态上下文中使用super,

3.41 语法

supper.成员表量
supper.成员方法([参数一，参数二...])

注意:
1.Super()只能用在子类的构造方法中使用，在其它地方使用存在编译错误。
2.super（）构造的父类只有在子类中有效，离开子类无法使用。
3.super.的调用的是由在子类构造的时候使用了super()的无参或者有参构造出来的父类。
4.当父类为有参构造而不写无参构造的时候，我们子类构造方法必须拥有父类的构造方法就需要用Super(String xx,int no)的构造方法将把父类构造出来才能继续构造子类。
5.当存在子类没有重写父类的方法时候，此时使用this.与super. 的结果相同

3.42 示例

public class Animal{
	String name = "动物";
	//定义动物叫的方法
	void show() {
		System.out.println("叫!");
	}
    //求和
	void add(int a,int b) {
		System.out.println(a+"+"+b+"="+(a+b));
	}
}

public class Dog extends Animal{
 
	//在eclipse中： alt+shift+s选择Override ...进行方法重写
	@Override   //@Override 强制检查方法是否是重写的方法
	//重写父类的方法
	void show() {
		super.show(); //访问父类的成员方法
	}
    @Override
	void add(int a, int b) {
		super.add(a, b); //访问父类有参成员方法
	}

	//定义打印name的方法
	void printName() {
		System.out.println("name="+super.name); 访问父类的成员变量
	}
	//为什么要写main方法，有main方法才可以测试输出
    public static void main(String[] args) {
    	//可以怎么讲，想要使用main方法外面的属性，就要实例化
		Dog dog = new Dog();
		dog.show();   //叫!
        dog.add(13,14 ); //13+14=27
		dog.printName();  //name=动物
	}
}

4.接口 *

 4.1 什么是接口

接口是一种标准，可以用于内部模块对模块、外部系统对其他服务提供的可调用或连接的能力的标准1。在Java语言中，接口是一种类型，是方法的集合，包含抽象方法、默认方法和静态方法，是对功能的扩展，也是声明规则的一种方式2。它是数据传递的通道，也是后台的一个函数，接口文档里面描述的接口参数其实就是函数的参数，接口的返回数据就是函数的返回值

 4.2 注意

1. 定义接口使用interface关键字

2. 接口的方法默认都是public abstract的,可以省略

3 .接口中的变量默认都是public static final类型的，所以必须显示的初始化

4.定义默认方法和静态方法时，可以有方法体

5.接口的实现类必须实现接口中的所有抽象方法

6.接口的实例化对象可以访问接口中的常量、接口实现方法、以及默认方法，静态方法(类方法)可以直接使用接口名调用；

7.接口和接口可以有继承关系

 4.3 语法

[修饰符] interface 接口名 [extends 父接口1,父接口2...] {
      [public] [static] [final] 常量类型 常量名 = 常量值;
      [public] [abstract] 方法返回值类型 方法名（[参数列表1]）;
      [public] [default] 方法返回值类型 方法名（[参数列表1]{
           //默认方法的方法体
      };
      [public] [static] 方法返回值类型 方法名（[参数列表1]{
           //类方法的方法体
      };
      
}

4.4 示例

public interface Animal {
	  //定义全局变量
      int ID = 1;   //默认是public static final修饰
      //定义抽象方法
      void breathe();   //默认是public abstract修饰
      //定义一个默认方法
      default void getType(String type) {
    	  System.out.println("该动物属于: "+type);
      }
      //定义一个静态方法
      static int getID() {
    	  return Animal.ID;
      }
} 

//实现Animal接口
public class Dog implements Animal{
	//实现接口中的抽象方法
	@Override
	public void breathe() {
		// TODO Auto-generated method stub
		System.out.println("狗在呼吸!");
	}
	
    public static void main(String[] args) {
    	//通过接口名调用类方法
    	System.out.println(Animal.getID());
    	//实例化Dog
		Dog dog = new Dog();
        //获取接口全局变量
		System.out.println(dog.ID);
		//调用breath方法
		dog.breathe();
		//调用getType方法
		dog.getType("犬科");
	}
}

5.异常

5.1 异常的类型

编译时异常：编译时异常的特点是在程序编写过程中，Java编译器就会对编写的代码进行检查，如果出现比较明显的异常就必须对异常进行处理，否则程序无法通过编译。
处理编译时异常有两种方式，具体如下：
·使用try……catch语句对异常进行捕获处理。
·使用throws关键字声明抛出异常，让调用者对其处理。

运行时异常:  运行时异常是在程序运行时由Java虚拟机自动进行捕获处理的，即使没有使用try…catch语句捕获或使用throws关键字声明抛出，程序也能编译通过，只是在运行过程中可能报错.

常见的运行时异常

异常类名称	异常类说明
ArithmeticException	算术异常
IndexOutOfBoundsException	角标越界异常
ClassCastException	类型转换异常
NullPointerException	空指针异常
NumberFormatException	数字格式化异常

5.2 语法

public class add {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        try {
			//可能发生异常的语句
        	int[] arr = {1,2,3};
        	System.out.println(arr[3]); //角标越界异常
		} catch (Exception e) {   
			//对捕获的异常进行处理
			e.printStackTrace(); //追踪输出标准错误流 
		}finally {
			//执行finally语句块，无论程序是否异常，都会执行
		}
	}

}

6.javaWeb以及spring学习需要掌握面向对象的知识:下篇

http://t.csdn.cn/RuZBS