java笔记二（面向对象）

对象和类

面向对象的三大特征：
封装
继承
多态

对象：
客观存在，能相互区分，具有明确状态(特征)和行为(功能)的，就是对象

类：
对象的集合，但是这些对象的状态和行为必须相似
类型相同的数据的集合

对象和类的关系：
类是对象的抽象形式 (类是模板)
对象是类的具体形式（对象是实物）

对象和类的区别：
类是抽象的
对象是具体的(有自己的状态和行为)
由一个类是可以产生出n个对象(一个模板可以生产出n个实物出来，而且这些实物一定是相似的)

类的实现：
类的成员：写在类中的，就统称为类是成员

访问修饰符   class  类名 {
	//类的成员(成员变量、方法).......
	private  String stuno;	//一个私有的：成员变量
	
	public  void setStuNo(String stuno){		//对应一个公有的：赋值方法		this作用：因为方法的参数名与成员变量同名，才需要this进行说明
		this.stuno = stuno;
	}

	public String getStuNo(){
		return stuno;			//对应一个公有的：取值方法		对应的字段什么类型，方法的返回值就是什么类型
	}
}

由类产生对象：
实例化的过程（new）

//类名   对象名  = new  类名();			
Student s1= new Student();		//s1就是具体的对象名
//对象名.方法名();			
s1.setStuNo("T123001");
System.out.println(s1.getStuNo());   //输出：T123001

访问修饰符：

修饰符		当前类		同一包内		子孙类(同一包)		子孙类(不同包)		其他包
public		  Y	 	   	  Y		    	 Y			        Y			      Y
protected	  Y		  	  Y		     	 Y			       Y/N（说明）		  N
default	  	  Y		  	  Y		    	 Y			        N			      N
private		  Y		  	  N		   	     N		  	        N			      N

默认访问修饰符-不使用任何关键字

类的访问修饰符：public 和 default
成员变量的访问修饰符：4种都可以

构造方法：
命名要求：
与类同名，没有返回值
作用：
初始化类的成员
执行时间：
创建对象时自动执行
注意：
1. 构造方法允许重载，执行时程序根据参数自动进行匹配
2. 一个类创建后，默认自带一个“无参构造方法”
但是，如果自己在类中去定义了有参构造方法，那么无参构造方法“消失”
如果要同时使用无参和有参，可以根据需要定义多个

方法重载：
在同一类中，方法名称相同，但参数的：类型、顺序、个数。其中一个不同就是方法重载

列：封装

package com.zuxia;

/**
 * 
 * 计算器
 *
 */
public class Calculator {
	//成员变量
	private double num1;
	private double num2;
	
	//为成员变量赋值取值定义接口
	public double getNum1() {
		return num1;
	}
	public void setNum1(double num1) {
		this.num1 = num1;
	}
	public double getNum2() {
		return num2;
	}
	public void setNum2(double num2) {
		this.num2 = num2;
	}
	
	//构造方法（初始化成员变量）
	public Calculator( double num1, double num2){
		 this.num1 = num1;
		 this.num2 = num2;
	}
	
	public Calculator(){
	}
	
	//成员方法
	public double Plus(){
		return num1 + num2;
	}
	
	public double Less(){
		return num1 - num2;
	}
	
	public double Ride(){
		return num1 * num2;
	}
	
	public double Except(){
		return num1 / num2;
	}
}

package com.zuxia;

import java.util.Scanner;

public class testCalculator {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in); 
		Calculator c1 = new Calculator();
		System.out.println("请输入第一个数字：");
		c1.setNum1(sc.nextDouble());
		System.out.println("请输入第二个数字：");
		c1.setNum2(sc.nextDouble());
		System.out.println("请输入计算方式：+-*/（分别用1234代替）");
		int sign = sc.nextInt();
		if(sign == 1){
			System.out.println("Result:"+c1.Plus());
		}else if(sign == 2){
			System.out.println("Result:"+c1.Less());
		}else if(sign == 3){
			System.out.println("Result:"+c1.Ride());
		}else if(sign == 4){
			System.out.println("Result:"+c1.Except());
		}
		
		System.out.println();
		
		Calculator c2 = new Calculator(10,20);
		System.out.println("请输入计算方式：+-*/（分别用1234代替）");
		int sign1 = sc.nextInt();
		if(sign1 == 1){
			System.out.println("Result:"+c2.Plus());
		}else if(sign1 == 2){
			System.out.println("Result:"+c2.Less());
		}else if(sign1 == 3){
			System.out.println("Result:"+c2.Ride());
		}else if(sign1 == 4){
			System.out.println("Result:"+c2.Except());
		}
	}
}

运行结果为：

请输入第一个数字：
2
请输入第二个数字：
2
请输入计算方式：+-*/（分别用1234代替）
1
Result:4.0

请输入计算方式：+-*/（分别用1234代替）
3
Result:200.0

继承与多态

继承：
是指一个类继承自另一个类

优点：
1. 提高代码的复用性(减少代码冗余)
2. 父类的属性方法可以用于子类
3. 可以轻松定义子类
4. 使设计应用程序变得简单
5. 更容易扩展
6. 代码的利用
7. 程序的设计变得更简单、维护更容易

继承后意味着：
子类拥有父类的所有成员（私有的除外）

注意事项：
两个类之间要实现继承，必须满足is a关系
例如：dog is animal
teacher is person

继承的语法：

class  B   extends A{
}

B类：子类，派生类
A类：父类，基类

class C extends B{
}

C类：子类，派生类
B类：父类，基类

继承特性：
单根性(单继承，是指一个类的父类只有一个) 但是：一个父类可以拥有多个子类
传递性(C类拥有B类和A类的所有成员，私有私外)

注意事项：
类在继承之后，构造方法的执行过程是：先执行父类构造，再执行子类构造

this.成员名：访问当前类的成员
super.成员名：访问父类的成员
例如：
super(…)：表示父类构造方法

Object类：所有类的父类（最终类）

多态：
多种形态
不同的人对于同一件事情做出了不同的反应
父类的一个方法，在不同的子类中可以有不同的实现
重写(子类重写父类的方法体)

注：
1.子类对于父类的方法：可以重写，可以不重写(不重写就执行父类的方法)
2.子类重写父类方法时：只能重写方法体(不能修改方法的定义：访问修饰符　返回值　　方法名　参数)

列：继承与多态

package com.zuxia.demo;
/**
 * 
 * @author Administrator
 *	父类：动物类
 */
public class Animal {
	
	public Animal(String color,String type){
		this.color = color;
		this.type = type;
	}
	public Animal(){
		
	}
	
	private String color;
	private String type;
	
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	
	public String jiao(){
		return "叫";//因为不知道具体是什么叫声，就先返回一个叫
	}
}

package com.zuxia.demo;
/**
 * 
 * @author Administrator
 *	子类：猫类
 */
public class Cat extends Animal {
	public Cat(String color,String type){
		super(color,type);
	}
	public Cat(){
		
	}
	public void Catjiao(){
		System.out.println("我的颜色是"+this.getColor()+",我是一只"+this.getType());
	}
	//重写父类（多态）
	public String jiao(){
		return "喵喵叫";
	}
}

package com.zuxia.demo;
/**
 * 
 * @author Administrator
 *	子类：狗类
 */
public class Dog extends Animal {
	public Dog(String color,String type){
		super(color,type);
	}
	public Dog(){
		
	}
	public void dogjiao(){
		System.out.println("我的颜色是"+this.getColor()+",我是一只"+this.getType());
	}
	//重写父类（多态）
	public String jiao(){
		return "汪汪叫";
	}
}

package com.zuxia.demo;
/**
 * 
 * @author Administrator
 *	测试类
 */
public class test {
	public static void main(String[] args) {
		Dog d1 = new Dog();//无参
		d1.setColor("黄色");
		d1.setType("狗");
		d1.dogjiao();
		System.out.println(d1.jiao());//有参
		System.out.println();
		Dog d2 = new Dog("黄色","狗");
		d2.dogjiao();
		System.out.println(d2.jiao());
		System.out.println();
		
		Cat c1 = new Cat();
		c1.setColor("黑色");
		c1.setType("猫");
		c1.Catjiao();
		System.out.println(c1.jiao());
		System.out.println();
		Cat c2 = new Cat("黑色","猫");
		c2.Catjiao();
		System.out.println(c2.jiao());
	}
}

运行结果：

我的颜色是黄色,我是一只狗
汪汪叫

我的颜色是黄色,我是一只狗
汪汪叫

我的颜色是黑色,我是一只猫
喵喵叫

我的颜色是黑色,我是一只猫
喵喵叫

里氏替换原则：
子类可以完全替换父类，能出现在父类出现的任何地方
Person p = new Student();
p.成员

static：静态的
作用：
修饰成员变量和成员方法
注意：
在java中如果用static去修饰符，这个类只能是：内部类

调用时的区别：
静态成员：类名.成员名
非静态成员：对象名.成员名 (必须先new一下)

定义的时的区别：
静态成员：属于整个类（与对象无关）
非静态成员：属于当前所创建它的对象（不同的对象名点出的方法的值不一样的，因为每个对象都有自己的特性和行为）

内存中的区别：
静态成员：只有一份
非静态成员：有多少个对象，就有多少份

注意：
静态方法：只能引用静态成员变量
非静态方法：静态和非静态都可以

final：最终的
注意：
1.如果用final去修饰类，就是最终类，表示不能被继承
2.如果用final去修饰变量，就是常量，表示值不变

abstract：抽象的
作用：
用来修饰类或类的成员
修饰类：抽象类
修饰方法：抽象方法

抽象方法：
1.没有方法体
2.只能包含在抽象类中
3.子类必须实现
4.不能是private的(因为抽象方法是用来让子类实现的，而如果用private修饰了，只能是不能访问的)

抽象类：
1.不能被实例化(原因：如果一个类是抽象类，必须类中有抽象方法，抽象方法是没有实现的，去实例化抽象类没有意义，应该去实例化它的子类)
2.抽象类的意义所在是：专门用来让子类继承的
3.抽象方法所在的类一定是抽象类，但抽象类中的方法不一定都是抽象方法（因为抽象类中可以包含其它方法）

语法：

访问修饰符 abstract class 类名{
	类的成员....

访问修饰符 abstract  返回值  方法名();	//抽象方法没有方法体，只能在抽象类中
}

Interface：接口
作用：
用来让子类实现（一个类可以实现自多个接口）

接口定义的语法：

访问修饰符  Interface   接口名{
	接口中的成员....
	如方法：pubic void read();	//接口中的方法：没有方法体，默认修饰符是public
}

实现接口的语法：

public class 类名 implements 接口1,接口n{
	............
}

继承自类并实现接口：

public class 类名 extends 父类  implements 接口1,接口n{
	............
}

接口特点：
可以被多个类实现
不能被实例化

接口方法的特点：
没有方法体
默认修饰符是public
实现自接口的类：必须实现接口中的方法

接口与抽象类的对比：
都是被实例化（因为有没有实现的方法，实例化没有意义）
接口是：多实现 类是：单继承

多态的实现方式：
方式1：重写（父类的方法，子类可以进行重写）
方式2：抽象类（抽象方法没有实现，子类必须实现）
方式3：接口（方法没有实现，子类必须实现）