Java学习-面向对象(中)-创新互联

高内聚低耦合，信息隐藏，属性私有
private，set()、get()

public class Student{private int age;
	public int getAge(){return this.age;}
	public void setAge(int age){if(age<120 && age>0){this.age=age;}else{	System.out.println("输入不合法");
		}
	}
}
public class Demo{public static void main(String[] args){Student s = new Student();
		s.setAge(-10);//输入不合法
	}
}

封装作用
1.保护数据，提升程序安全性
2.隐藏代码实现细节
3.统一接口
4.提高系统可维护性

extends，类之间的关系，除了继承还有依赖、组合、聚合等

public class Person{public void say(){System.out.println("say something.");}
}
public class Student entends Person{}
public class Demo{public static void main(String[] args){Student s = new Student();
		s.say();//say something.
	}
}

子类拥有父类的全部方法
Object类：在Java中，所有的类都默认继承Object类
Java只有单继承，没有多继承

public class Person{protected String name = "a";
	public Person(){System.out.println("Person无参构造");}
	public void print(){System.out.println(Person);}
}
public class Student entends Person{private String name = "b";
	public Student(){System.out.println("Student无参构造");}
	public void print(){System.out.println(Student);}
	public void test1(String name){System.out.println(name);
		System.out.println(this.name);
		System.out.println(super.name);
	}
	public void test2(){print();this.print();super.print();}
}
public class Demo{public static void main(String[] args){Student s = new Student();//Person无参构造 \n Student无参构造
		s.test1("c");//c \n b \n a
		s.test2();//Student \n Student \n Person
	}
}

super注意：
1.子类使用super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或构造方法中
3.super和this不能同时调用构造方法
super VS this：
代表对象不同：this调用者对象，super父类对象
前提不同：this没有继承也可以使用，super只能在继承条件下才可以使用
构造方法：this调用本类构造，super调用父类构造

静态方法：静态方法是类的方法，p调用父类Person的方法，实例化的子类对象向上转型为父类对象

public class Person{public static void test(){sout("Person.test()");}
}
public class Student extends Person{public static void test(){sout("Student.test()");}
}
public class Demo{public static void main(String[] args){Student s = new Student();
		s.test();//Student.test()
		Person p = new Student();
		p.test();//Person.test()
	}
}

非静态方法：非静态方法是对象的方法，在子类实例化时重写了父类的方法

public class Person{public void test(){sout("Person.test()");}
}
public class Student extends Person{public void test(){sout("Student.test()");}
}
public class Demo{public static void main(String[] args){Student s = new Student();
		s.test();//Student.test()
		Person p = new Student();
		p.test();//Student.test()
	}
}

重写：
1.需要有继承关系
2.方法名相同
3.参数列表相同
4.修饰符的范围可以扩大但不能缩小
5.抛出的异常：范围可以被缩小但不能扩大
6.快捷键：Alt+Insert → override
为什么需要重写
子类不一定需要父类的功能，或者父类不一定满足子类的需求

动态编译
对象的实际类型是确定的，但可以指向的引用类型不确定

Person p = new Student();//父类的引用指向子类的类型
Object o = new Student();

子类能都用的方法，要么是自己的，要么是继承的；父类只能调用自己的方法，不能调用子类独有的方法

public class Person{public void run(){sout("Person.run()");}
}
public class Student extends Person{public void run(){sout("Student.run()");}
	public void eat(){sout("Student.eat()");}
}
public class Demo{public static void main(String[] args){Student s = new Student();
		s.eat();//Student.eat()，自己的
		s.run();//Student.run()，重写的
		Person p = new Student();
		p.run();//Student.run()，重写的
		p.eat();//×，子类独有的
	}
}

注意：
1.多态是方法的多态，属性没有多态
2.父类和子类有联系，如果没关系会有类型转换异常，ClassCastException
3.存在条件：继承关系、重写，父类引用指向子类对象

public class Person{public void test(){sout("Person.test()");}}
public class Student extends Person{public void test(){sout("Student.test()");}}
public class Teacher extends Person{public void test(){sout("Teacher .test()");}}
public class Demo{public static void main(String[] args){Person p1 = new Person();
		Person p2 = new Teacher();
		Person p3 = new Student();
		p1.test();//Person.test()
		p2.test();//Teacher.test()
		p3.test();//Student.test()
	}
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧