第一周课前预习（面向对象三大特性）

---

面向对象三大特性

---

1. 封装

概念：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的信息进行隐藏。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

在Java中类成员的属性有：public,protected,< default >,private,这四个属性的访问权限依此降低。

封装的简单例子

public class Text {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s1= new Student();//错误：私有属性在类的外部不可访问。
		s1.age=20000;
	}

}

class Student{
	String name;
	private int age；//将属性修饰为私有。
	String sex;
}

公共访问方法

外界访问private属性，不可直接访问属性，仅可访问公共方法。
get/set方法是外界访问对象私有属性的唯一通道，方法内部可对数据进行检测和过滤。

public class Text {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s1= new Student();
		s1.setAge(20000);//以访问方法的形式，进而完成赋值取值操作。
		System.out.println(s1.getAge());//合法
		
	}

}

class Student{
	String name;
	private int age;
	String sex;
	public int getAge() {
		return age;
	}//使用方法返回值实现取值
	public void setAge(int age) {
		this.age = age;
	}//使用方法参数实现赋值
	
}

---

2.继承

概念：继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。

父类的抽象：可根据实际程序所需要使用到的多个具体类，进行共性抽取，从而定义父类。
子类功能越精细，重合点越多，越接近直接父类；功能越粗略，重合点越少，越接近Object类

继承的简单例子

public class Textdog{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog cc=new Dog();
		cc.age=10;//调用父类的成员变量
	}
}
class Dog extends Animal{
	public void run() {
		System.out.println("跑....");
	}
}//继承了Animal中的属性
class Animal{
	int age;
	String color;
	char sex;
}

继承的语法

语法：class 子类 extends 父类 { }//定义子类时显示继承父类
应用：产生继承关系后，子类可以使用父类中的属性和方法，也可定义子类独有的属性和方法。
好处：提高代码的复用性，又提高代码的可拓展性。

特点：Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加

不可继承的情况

1.构造方法：类中的构造方法，只负责创建本类对象，不可继承。
2.private修饰的属性和方法：访问修饰符的一种，仅本类可见。（详情见下图）
3.父子类不在同一个package时，default修饰的属性和方法。（详情见下图）

方法的覆盖

当父类提供的方法无法满足子类需求时，可在子类中定义和父类相同的方法进行覆盖。

super的用法

1.super关键词可在子类中访问父类的方法。使用"super."的形式访问父类的方法，进而完成在子类中的复用；再叠加额外的功能代码，组成新的功能。

public class Text{
	public static void main(String args[]) {
	A text=new A();
	text.speak();
	}
}
class A extends B {

	public void speak() {
		super.speak();//调用父类speak方法
		System.out.println("调用A的speak");
	}

}
class B{
	public void speak(){
		System.out.println("调用B的speak");
	}
}

结果：
调用B的speak
调用A的speak

2.super（）：表示调用父类无参构造方法。如果没有显示书写，隐式存在于子类构造方法的首行。
super（实参）：表示调用父类有参构造方法。
3.this与super的区别与相似：
this表示当前对象引用，调用本类（包括继承）的属性,方法,本类构造方法。
super表示父类对象引用，调用父类的属性,方法,构造方法。
this和super使用再构造方法中时，都要求再首行。当子类构造中使用了this（）或this（实参），即不可再使用super（）或super（实参），会由this（）指向的构造方法完成super（）的调用。

public class Text{
	public static void main(String args[]) {
	A test=new A(1);//调用构造方法
	}
}
class A extends B {
	public 	A() {
		super();//调用父类的无参构造方法
		System.out.println("A的无参构造");
	}
	public A(int m)
	{
		this();//调用本类的无参构造方法
		System.out.println("A的有参构造");
	}
}
class B{
	public B() {
		System.out.println("B的无参构造");
	}
	public B(int n) {
		System.out.println("B的有参构造");
	}
}

结果：
B的无参构造
A的无参构造
A的有参构造

3.多态

概念：多态是同一个行为具有多个不同表现形式或形态的能力。多态指父类引用指向子类对象，从而产生多种形态。

多态的简单例子

public class Text{
	public static void main(String args[]) {
	Animal dog=new Dog();//父类引用指向子类对象形成多态
	}
}

class Animal{
	int age;
	String sex;
	public void eat() {
		System.out.println("吃...");
	}
}
class Dog extends Animal {
	String furcolor;
	public void run() {
		System.out.println("跑...");
	}
}

多态的两种应用场景

1.使用父类作为方法形参，实现多态。

public class Text{
	public static void main(String args[]) {
	Animal cc=new Bird();
	Master master=new Master();
	master.skill(cc);
	}
}//使用多态进行优化behavior

class Animal{
	int age;
	String sex;
	public void behavior() {
		System.out.println("吃...");
	}
}
class Dog extends Animal {
	public void behavior() {
		System.out.println("跑...");
	}
}
class Bird extends Animal{
	public void behavior() {
		System.out.println("飞...");
	}
}
class Master{
	String name;
	public void skill(Animal animal) {
		animal.behavior();
	}//利用父类作为该方法的形参

结果
飞…

2.使用父类作为方法返回值，实现多态。

import java.util.Scanner;

public class Text{
	public static void main(String args[]) {
	System.out.println("请输入数字购买动物:");
	Scanner in=new Scanner(System.in);
	int chioce=in.nextInt();
	Buy buyer=new Buy();
	Animal animal=buyer.Buyanimal(chioce);//传递父类返回值
	System.out.println("购买成功");
	}
}

class Animal{
	int age;
	String sex;
	String name;
}
class Dog extends Animal {
	String furcolor;
}
class Bird extends Animal{
	String wings;
}
class Buy{
	public Animal Buyanimal(int type){
	Animal animal=null;
	if(type==1)
		animal=new Dog();
	else if(type==2)
		animal=new Bird();
	return animal;
	}//使用父类作为该方法的返回值
}

向上转型与向下转型

向上转型（装箱）：定义与引用如下图。

向下转型（拆箱）:定义与引用如下图。

注意：向下转型必须先向上转型然后再向下转型。

instanceof关键字

向下转型前，应先判断引用中的对象的真实类型，保证类型转换的正确性。
语法：引用intanceof类型//返回Boolean类型结果。

public class Text{
	public static void main(String args[]) {
	Animal a=new Dog();
	if(a instanceof Dog )//判断a是否是Dog类型
	{
		Dog dog=(Dog)a;//向下转型
		dog.eat;
	}
	}
}

总结

面向对象编程主要体现在这三个基本特征中，个人感觉最简单的应该是封装，知识点也相对较少，然后继承和多态都需要掌握好父类和子类的相关知识还有方法覆盖，一些关键词之类的，还需要对其进行灵活运用，对于我这个小白来说，预习这块还是用了很久的（qwq用了一天半，然后写代码也有很多bug在不断的修改…最后写出了这篇blog），然后就是后续还需要更多的练习和运用才能更好掌握这三个基本特征。加油咯~