面向对象

Java类及类的成员：属性，方法，构造器，代码块，内部类
面向对象的三大特征：封装性，继承性，多态性，(抽象性)
其他关键字：this , super , static ,final ,abstrcat , interface , package ,import

面向对象程序设计的重点是类的设计
设计类即设计类成员
什么是类?
类是对一类事物的描述，抽象的概念上的定义
怎么创建一个类？
什么是对象?
实际存在的该类事物的每个个体（实例）
怎么创建一个对象？
怎么使用一个对象？
*属性：对应类中的成员变量
*行为：对应类中的成员方法即函数

---

类和对象的使用

package object;

public class object1 {

	public static void main(String[] args) {
		//创建Person类的对象即实例化
		Person p1=new Person();
		//调用对象的结构：属性，方法
		//调用属性：对象.属性;
		p1.name="Tom";
		p1.isMale=true;
		System.out.println(p1.name);
		//调用方法：对象.方法;
		p1.eat();
		p1.sleep();
		p1.talk("Chinese");

	}

}
//创建Person类
class Person{
	//属性
	String name;
	int age=1;
	boolean isMale;
	//方法
	public void eat() {
		System.out.println("人吃饭");
		
	}
	public void sleep() {
		System.out.println("人睡觉");
	}
	public void talk(String language) {//有参 
		System.out.println("人说话，使用的是："+language);
	}
}

1 封装性的理解：
创建一个类的对象后，可通过对象.属性对对象的属性进行赋值，此时赋值操作要受属性的数据类型和存储范围制约，but需给属性赋值加入额外的限制条件，条件不能在属性声明时体现，只能通过方法进行限制条件的添加（如setName()）
同时避免用对象.属性对属性赋值，需将属性声明为私有的private。
将类的属性xxx私有化(private),同时提供公共的（public）方法来获取getXxx和设置setXxx此属性的值
1 复杂性封装，对外提供简单的操作入口。
2 private 修饰的数据只能在本类中访问

/*set方法的命名规范
 * public void setAge(int a){
 * age=a;
 * }
 * get方法的命名规范
 * public int getAge(){
 * return age;
 * }
 * setter and getter方法没有static关键字
 * 有关键字static关键字修饰符方法怎么调用:类名.方法名(实参);
 * 没有static关键字如何调用：引用.方法名(实参);
 */

package object;

public class object2 {

	public static void main(String[] args) {
		Person1 p1=new Person1();
		Person1 p2=new Person1("胡大爷",78,"男","广场舞领舞的");
		System.out.println(p1.getName());
		System.out.println(p2.getName());
		p1.setName("胡图图");
		System.out.println(p1.getName());
	
	}
}//类的封装性
class Person1{
	private String name;
	private int age;
	private String gender;
	private String work;
	public Person1() {//无参的构造方法
		
	}
	public Person1(String name,int age,String gender,String work ) {//有参的构造方法
		this.name=name;
		this.age=age;
		this.gender=gender;
		this.work=work;
		
		
	}
	//设置方法
	public void setGender(String gender) {
		this.gender=gender;
	}
	//获取方法（有返回值）
	public String getGender() {
		return this.gender;
	}
	//shift  Alt  S
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getWork() {
		return work;
	}
	public void setWork(String work) {
		this.work = work;
	}
	
}

2 继承性
格式：class A extends B{ }
A:子类，派生类，subclass
B:父类，超类，基类，superclass
体现：A继承B后，A获取了B中声明的所有属性和方法
父类中声明为private的属性或方法，子类继承父类以后，仍然获取了父类中私有的结构
因为封装性，使子类不能直接调用父类的结构

package object;

public class object3 {

	public static void main(String[] args) {
		Student s=new Student();
		s.talk();
		s.sleep();
		System.out.println(s.getName());
		s.setName("胡大爷");
		System.out.println(s.getName()); 

	}

}
class Person2{
	protected String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}public void sleep() {
		System.out.println("父类中的sleep()");
	}
	private void eat() {
		System.out.println("父类中的eat()");
    }
	protected  void talk() {
		System.out.println("父类中的talk()");
	}
}
class Student extends Person2{
	public void sleep() {
		System.out.println("小学生库里要睡午觉");
	}

	
	
	
}	
		
		

3 多态性

• 一个事物多种形态
• 特点：多态性形式的对象（Person3 p1 = new Man();）
• 此对象只能调用父类中声明过的方法或者子类中重写过得方法
• 规律：调用方法时，先看右边再看左边
• 创建方式：通过子类的构造方法创建一个父类的对象

package object;
public class object4 {
	public static void main(String[] args) {
		Person4 p1=new Person4();
		p1.eat();
		Man man=new Man();
		man.eat();
		man.age=25;
		man.earnMoney();
//***********************************************8
	//对象的多态性：父类的引用指向子类的对象(子类的对象赋给父类的引用)
		Person4 p2=new Man();//编译看左，运行看右
		//Person4 p3=new Woman();
		//多态的使用：当调用子父类同名同参的方法时，实际执行的是子类重写父类的方法---虚拟方法调用
		//多态的前提条件1 类的继承2 方法的重写
		
		p2.eat();
		p2.walk();
		
		
		

	}

}
class Person4{
	String name;
	int age;
	public void eat() {
		System.out.println("人吃饭");
	}
	public void walk() {
		System.out.println("人走路");
	}
}
class Man extends Person4{
	boolean isSmoking;
	public void earnMoney() {
		System.out.println("男人挣钱");
	}
	//重写方法
	public void eat() {
		System.out.println("男人多吃饭");
	}
	public void walk() {
		System.out.println("走路拽");
}
class Woman extends Person4{
	boolean isBeauty;
	public void goShopping() {
		System.out.println("女人购物");
	}
	//重写方法
	public void eat() {
		System.out.println("仙女不吃饭");
	}
	public void walk() {
		System.out.println("扭扭");
	}
}}

4 接口的实现

package foryou.classTest;


//定义接口
interface Person4{
	public static final int MAX = 100;
	int a = 10;
	public abstract void eat();  //修饰词： public abstract（默认）
	public void special();
	public void sleep();
	
	public static void speak() { //静态方法
		System.out.println("英文");
	}
	public default void speak2() { //静态方法
		System.out.println("英文");
	}
}
class Man2 implements Person4{
	public void eat() {
		
	}
	public void special() {
		
	}
	public void sleep() {
		
	}
	
}

class Woman2 implements Person4{
public void eat() {
		
	}
	public void special() {
		
	}
	public void sleep() {
		
	}
}
public class Dome4 {
	public static void main(String[] args) {
		Man2 m = new Man2();
	}
}

构造器

/*构造方法又称构造器Constructor
 * 构造方法语法结构
 * 【修饰符列表】构造方法名(形式参数列表){
 *    构造方法体;
 *    }
 *  构造方法名必须与类名保持一致。
 *  构造方法的作用：
 *  通过构造方法的调用可以创建对象。
 *  构造方法如何调用？
 *  new 构造方法名(实参列表);
 */