笔记 面相对象

面向对象

构造器

1. 名称和类名相同
2. 没有返回值

作用

1. new 本质是在调用构造方法

2. 初始化对象的值

注意

定义有参构造之后，想使用无参构造，必须显示地定义无参构造

package demo01;

public class GouZaoQi {
	//一个类即使什么都不写，也会存在一个方法
	//
	String name;
	//构造器    
	//1使用new关键字，本质是在调用构造器。
	//2用来初始化值
	public GouZaoQi() {           //默认构造器
	}
	
	//定义一个有参构造时，必须显示地定义无参构造
	public GouZaoQi(String name) {//重载
		this.name = name;
	}
}

package demo01;

public class Application {
	public static void main(String[] args) {
		GouZaoQi gouZaoQi = new GouZaoQi("小红");
		System.out.println(gouZaoQi .name);
	}
}

封装

属性私有，get/set

程序设计追求 高内聚，低耦合

public class Application {
	public static void main(String[] args) {
		Student student = new Student();
		student.setName("小明");
		System.out.println(student.getName());
		student.setAge(80);
		System.out.println(student.getAge());
	}
}

public class Student {
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>120 || age<0) { //可以在set方法中设置一些安全性的判断
			this.age = 3;
		}else {
			this.age = age;
		}
	}
	private String name;
	private int age;
	private int weight;
	//get 获得这个数据
	public String getName() {
		return this.name;
	}
	//给这个数据设置值
	public void setName(String name) {
		this.name = name;
	}
}

封装的意义：

1. 提高程序的安全性，保护数据

2. 隐藏代码的实现细节

3. 统一接口

4. 系统的可维护性增加

封装就是数据的隐藏。通常应禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问，这称为信息隐藏。

继承

extends 关键字，意为“扩展“，子类是父类的扩展。

java中类只有单继承，没有多继承。

object类

• 继承是类和类之间的一种关系。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，有个 is a 的关系。

private关键字修饰的 、私有的东西无法被继承。

方法重写

需要有继承关系，子类重写父类的方法。

子类重写了父类的方法，执行子类的方法。

重写都是方法的重写，与属性无关。

重写只和非静态方法有关。

重写只能关键词是public。

1. 方法名必须相同。
2. 参数列表必须相同。 默认不写 Default
3. 修饰符 ：范围可以扩大，不能缩小。 public >Protected>Default>private
4. 抛出的异常：范围可以缩小，不能扩大。

子类的方法和父类的必须要一致，方法体不同。

public class Application {
	public static void main(String[] args) {
		//静态方法的调用只和等号左边定义的数据类型有关
		A a = new A();
		a.test();     //A
		//父类引用指向子类
		B b = new A();  //子类重写了父类的方法，执行子类的方法。
		b.test();     //B
	}
    
public class A extends B{
	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("A-test");
	}
}
public class B {
	public void test() {
		System.out.println("B-test");
	}
}

重写意义：

父类的功能子类不一定需要，或者不一定能满足。

多态

多态 ：即为同一方法可以根据发送对象的不同而采取多种不同的行为方式。

一个对象的实际类型是确定的，但是它可以指向的引用类型不确定。

多态是方法的多态，和属性无关。

存在条件：

1. 有继承关系

2. 方法需要重写

3. 父类的引用指向子类对象

   Father f = new Son();

不能重写的方法：

• static 方法，属于类，不属于任何实例。
• final 常量
• private 不能重写，没有多态。

public class Application {
	public static void main(String[] args) {
		
		Student s1 = new Student();
		Person s2 = new Student(); //父类的引用指向子类
		Object s3 = new Student();
		
		//对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
		s1.run();
		s2.run();
		((Student) s3).eat();
		((Student) s2).eat();//Person想执行子类独有的方法，需要强制转换为Student类型
	//  ((子类类型) 父类引用). 方法();   由高到低需要强制转换
	}
}

public class Person {
	public void run() {
		System.out.println("run");
	}
}

public class Student extends Person{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("sun");
	}
	public void eat() {
		System.out.println("eat");
	}
}

注意

抽象类

关键字 abstract

抽象类本质是类，单继承。是一种约束。

1. 不能new这个抽象类，只能靠子类去实现它，是一种约束。
2. 一个类里边一旦有抽象方法，这个类必须是抽象类；但是一个抽象类可以有不是抽象方法的方法。

//abstract 抽象类
public abstract class Act {
	
	//抽象方法  只有名字，没有实现
	public abstract void run();
    //抽象类里面也可以有常规方法
	public void eat() {
		System.out.println("eat");
	}
}

//抽象类的所有方法，继承它的所有的类，必须去实现这些方法     
//如果继承这个抽象类的也是抽象类，就以此类推...
public class A extends Act{

	@Override
	public void run() {
		// TODO Auto-generated method stub
	}
}

存在意义？

接口

接口可以多继承。

接口：只有规范，自己没有具体实现。 约束和实现分离，面向接口编程

接口的本质是契约，制定好之后都要遵守

用interface定义。

//定义关键字 interface       接口都需要一个实现类
public interface UserService {
    //接口中定义的常量都是 public static final     一般不这么用
    int age = 60;
	//接口中的定义的方法都是抽象的  public abstract 
	void add(String name); 
	void delate(String name);
	void update(String name);
	void query(String name);
}

//抽象类  extends 只能单继承 
//类  实现接口  关键字    implements 接口     可以多继承
public class UserServiceImpl implements UserService,TimeService{//利用接口 实现多继承
    @Override
	public void timer() {
		// TODO Auto-generated method stub
		
	}
    String name;
    public static void main(String[] args) {
    	UserServiceImpl userServiceImpl = new UserServiceImpl();
		String name = "xiaoming";
		userServiceImpl.add("小明");
		System.out.println(userServiceImpl.name);
	}
	//实现了接口的类，必须重写接口中的方法
	@Override
	public void add(String name) {
		// TODO Auto-generated method stub
		this.name = name;
	}

	@Override
	public void delate(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void update(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void query(String name) {
		// TODO Auto-generated method stub
		
	}
}

public interface TimeService {
	void timer();
}