JAVA面向对象总结

java面向对象的知识还是非常多的，也非常的抽象，有一定的难度，推荐多去写写，比如人类，学生类，公司类，动物类

package classdemo;
/*类：是抽象的概念,对象是具体的实体
 *对象的理解：一切事物皆为对象，对象一定是具体的，既可以是实物，也可以是一个概念
 *对象的几大特征：封装，继承，多态，抽象，唯一
 *对象的组成：
 *		属性：成员变量，对象具有的基本特征
 *		方法：成员方法，动作或行为
 *		对象是一个整体，不能分割，否则会破坏他的特征和行为
 *封装：是一种信息隐藏技术，把属性和方法包含再对象的内部，对外隐藏具体的细节，以对象的形式整体展现;通过get/set方法给其他人调用
 *需要通过对象来访问属性和方法
 *方法的重载：方法名相同,数据项不同,在同一个类中,与其他东西无关
 *继承：继承就是子类继承父类的特征和行为,使用extends关键字
 *重写：子类金额父类中有同名的方法在子类中重写,,方法名相同,参数列表相同,返回值类型相同或者是其子类,访问权限不能严于父类
 *构造方法不能被继承也不能被重写
 *super:1.只能出现在子类的方法和构造方法中2.调用 构造方法时只能是第一句3.不能访问父类的private成员
 *abstract抽象类：父类没有必要实例化,将父类定义为抽象类型,来限制实例化,但是其子类是可以实例化的
 *				抽象方法没有方法体,必须在抽象类里,抽象方法必须在子类中被实现
 *final：修饰的类不能被继承,修饰的属性变成不可以修改的属性(常量),修饰的方法不能被重写
 *
 * 
 */
public class Person {//用class来修饰类,这里Person就是类名,这就是个人类的类
	//这些就是人类所具有的属性,又叫成员变量或者全局变量(成员变量不需要初始化,系统会给他一个默认值),作用域为整个类
	String name;//名字
	String sex;//性别
	int age;//年龄
	static final String AGE_MAX = "赵六";
	//用final修饰的变量成为常量,其值固定不变;static为静态方法(类方法)：静态方法或者属性可以互相调用,静态方法无法直接调用普通方法,并且不能引用this或super,普通方法可以直接调用静态方法,静态方法只能用类名.属性或方法来调用
	//这就是人类speak的方法,方法的返回值类型是void,方法名是speak,方法之间允许互相调用
	public void speak() {//void是没有返回值的
		String str = "人能说话";//局部变量(没有初始值,需要手动初始化),作用域仅在这个方法里
		System.out.println(str);//方法体
	}
	public String buy(String goods,int number) {//参数列表,放在方法体的括号内的参数叫：形参(形参可以是各种数据类型)
		if(goods.equals("漫画书")) {//这里的goods就是实参,调用方法时传递给方法的实际值

		}
		return "买东西";
	}
	class Student{//定义一个Student类,在类里面封装一些属性和方法,给所有的对象使用(重复使用)
		public int id;
		public String name;
		public int age;
		public int grade;
		public void show() {
			System.out.println(id+" "+name+" "+age+" "+grade);
		}
	}
	public void addStudeng(Student student) {//将对象作为参数
	
	}
	public Person() {//无参数构造方法：1.方法名与类同名2.没有返回值3.与返回的修饰符无关;是给成员属性默认赋予初始值
		
	}
	public Person(String name,int id,String sex) {//有参构造方法(重载)(如果写了有参构造,就必须写一个无参构造,系统本身默认是由一个无参构造的,一旦写了有参构造,默认的就会消失)
		this.name = name;//这里this.name代表的时成员变量里面的name,为了区分成员变量和参数变量
		this.age = age;
		this.sex = sex;
	}
	static{//静态代码块只能给static的属性赋值,静态块比构造方法先执行,静态属性的内存会一直存在,直至退出,
		
	}
	public static void main(String[] args) {
		Person person = new Person();//这就是对象,实例化一个对象
		person.name="张三";//通过(对象名.属性的)的方法来引用类的属性,并且给属性赋值,其实就是通过无参构造来赋值(没有有参构造时系统有个默认的有参构造)
		person.age = 17;
		person.sex = "男";
		person.speak();//通过(对象名.方法名())的方法来引用类的方法
		Person person1 = new Person("王五",18,"男");//通过有参构造进行赋值
	}
}
abstract class Pet{//定义了一个抽象类
	private String name;
	public abstract void eat();//抽象方法没有方法体,必须写在抽象类里面,抽象方法必须由子类全部实现
	class Gog extends Pet{
		public void eat() {
				
		}	
	}
}
class Animal{
	public static void eat() {
		
	}
}
class Dog extends Animal{
	
	public static void eatBone() {
		
	}
}
class Cat extends Animal{
	public static void sleep() {
		
	}
}
class Master{//这里每加一个就要多写一个方法,十分不方便,于是这里引入了多态的概念
	public void feed(Dog dog) {
		dog.eat();
	}
	public void feed(Cat cat) {
		cat.eat();
	}
}
class Master1{//向上转型
	public void feed(Animal animal) {//直接将父类作为对象调用
		Animal.eat();
	}
	
	public Cat getCat() {
		return new Cat();
	}
	
	//向上转型    高级程序员，架构师  通用性
	public static  Animal getAnimal(int type) {
		if(type == 1) {
			return new Dog();
		}else {
			return new Cat();
		}
	}	
	public static void main(String[] args) {
		Animal animal = getAnimal(1); //得到一个动物类对象
		if(animal instanceof Dog) { //判断动物的具体类型
			//强制类型转换
			Dog dog = (Dog)getAnimal(2); //向下转型
		}else if(animal instanceof Cat) {
			
		}
	}	
}