封装: 属性私有、get/set
作用:1.提高程序的安全性、保护数据;
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
通常会在set方法里做一些安全性的验证和判断
public class FengZhuangDemo1 {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("敢敢");
System.out.println(s1.getName());
s1.setAge(444); //不合法的
System.out.println(s1.getAge());
}
}
class Student{
//属性私有
private String name;
private int age;
private char sex;
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get获得这个数据
public String getName(){
return name;
}
//set给这个属性设置值
public void setName(String name){
this.name = name;
}
// Alt+Insert
public int getAge() {
return age;
}
public char getSex() {
return sex;
}
public void setAge(int age) {
if (age > 150 || age <0){
System.out.println("输入不合法!");
}else {
this.age = age;
}
}
public void setSex(char sex) {
this.sex = sex;
}
}
继承:
Java中只有单继承没有多继承。
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一行
2.super必须只能出现在子类的方法或构造方法中!
3.super和this不能同时调用构造方法!
VS this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提:
this:没有继承也可以使用
super:只能在继承条件下才可以使用
构造方法:
this(): 本类构造
super(): 父类构造
/**
* 继承
* 在Java中,所有的类都默认直接或间接继承Object类
*/
public class InheritDemo1 {
public static void main(String[] args) {
Student1 student1 = new Student1();
// student1.test("敢敢");
// student1.test1();
}
}
// 父类 私有的无法被继承
class Person{
public Person(){
System.out.println("Person无参执行了");
}
protected String name = "father";
public void print(){
System.out.println("Person");
}
}
// 子类
class Student1 extends Person{
public Student1(){
//隐藏代码:super 调用了父类的无参构造
super(); // 默认调用super() 调用父类的构造器,必须放在子类构造器的第一行
System.out.println("Student无参执行了");
}
private String name = "son";
public void print(){
System.out.println("Student");
}
public void test1(){
print(); //Student
this.print(); //Student
super.print(); //Person
}
public void test(String name){
System.out.println(name); // 敢敢
System.out.println(this.name); // son
System.out.println(super.name); // father
}
}
重写:
只和非静态方法有关;
需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表必须相同
3.修饰符:范围可以扩大但不能缩小: public > Protected > Default > private
4.抛出的异常:范围 可以被缩小,但不能扩大: ClassBotFoundException < Exception
重写: 子类的方法和父类必须一致,方法体不同!
为什么要重写:
父类的功能,子类不一定需要,或者不一定满足!
Alt+Insert:override
/**
* 重写 都是方法的重写,和属性无关
*
* 静态的方法和非静态的方法区别很大:
* 静态方法: 方法的调用只和左边定义的数据类型有关
* 非静态: 重写
*/
public class OverrideDemo1 {
public static void main(String[] args) {
A a = new A();
a.test();
//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法
b.test();
}
}
class B{
public void test(){
System.out.println("B=>test()");
}
}
class A extends B{
//Override 重写
@Override //注解,有功能的注释!
public void test() {
System.out.println("A=>test()");
}
}
多态:
多态的注意事项: * 1.多态是方法的多态,属性没有多态 * 2.父类和子类,有联系extends 类型转换异常! ClassCastException! * 3.存在条件: 继承关系,方法需要重写,父类引用指向子类对象! Father f1 =new Son(); * * 不能重写: * 1.static 方法,属于类,它不属于实例 * 2.final 常量 * 3.private方法 * * * 1.父类引用指向了子类的对象 * 2.把子类转换为父类 ,向上转型 * 3.把父类转换为子类,向下转型,强制转换! * 方柏霓方法的调用,减少重复的代码! Teacher类 父类
/**
* 父类
*/
public class Teacher {
public void run(){
System.out.println("This is father");
}
}
Sthudent类 子类:
public class Student extends Teacher{
@Override //方法需要重写,否则调用的都是各自的方法
public void run() {
super.run();
}
public void eat(){
System.out.println("eat");
}
}
Application类:
public class Application {
public static void main(String[] args) {
//Student 能调用的都是自己的或继承父类的
Student s1 = new Student();
// 父类型,可以指向子类,但是不能调用子类独有的方法
Teacher s2 = new Student(); //父类的引用指向了子类
s2.run();
s1.run();
s1.eat();
Teacher teacher = s1; //子类转换为父类,可能丢失自己本来的一些方法
s1.eat();
// 对象执行哪些方法,主要看对对象左边的类型,和右边的关系不大
((Student)s2).eat(); //强制类型转换
}
}