**属性私有，getset
封装的意义：
1.提高程序安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统的可维护性增加了
public class Demo04 {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("凸凸");
s1.setAge(2);
System.out.println(s1.getName() + "," + s1.getAge());//凸凸,2
Student s2 = new Student();
s2.setName("凹凹");
s2.setAge(150);//不合法数据
System.out.println(s2.getName() + "," + s2.getAge());//凹凹,3
}
}
public class Student {
String name;
int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age > 120 || age < 0){//添加不合法年龄的判断
this.age = 3;
}else {
this.age = age;
}
}
}
2.继承
关键字是extends,java中只有单继承没有多继承（一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）
//在JAVA中,所有的类都默认直接或间接地继承Object
//父类，基类
public class Person {
private int money = 10_0000_0000;
public void speak(){
System.out.println("人说话");
}
public Person() {
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//子类，又叫派生类
//子类会继承父类的所有方法
public class Student extends Person{
}
public class Demo05 {
public static void main(String[] args) {
Student s = new Student();
s.speak();
System.out.println(s.getMoney());
}
}
super()详解
super代表父，this代表当前的
super注意点:
1.super调用父类的构造方法，必须在构造方法第一个
2.super必须只能出现在子类的方法或者构造方法中!
3.super和this不能同时调用构造方法!（因为都要求出现在第一个）
public class Person {
protected String name = "tutu";
public Person() {
System.out.println("父类无参被调用");
}
`}
```java
public class Student extends Person{
protected String name = "凸凸";
public Student() {
//隐藏代码：调用了父类无参构造
super();//调用父类的构造器必须要在子类构造器的第一行
System.out.println("子类无参被调用");
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);//子类
System.out.println(super.name);//父类
}
}
```java
public class Demo05 {
public static void main(String[] args) {
Student s = new Student();
s.test("矮脚猫");
}
}
方法重写：
重写:需要有继承关系,子类重写父类的方法!
-
方法名必须相同
-
参数列表必须相同
-
修饰符:范围可以扩大，不能缩小
//public
//protected
//default
//private -
抛出的一场:范围,可以被缩小,但不能扩大:ClassNotFoundException – >Exception(大)
重写:子类的方法必须与父类一致:方法体不同！
为什么重写:
1.父类的功能,子类不需要,或不一定满足！
快捷键：alt+insete:override
//重写都是方法的重写,和属性无关
public class B {
public void test() {
System.out.println("B=>test()");
}
}
//继承
public class A extends B {
//@Override 重写
@Override
public void test() {
System.out.println("A=>test()");
}
}
**
3多态多态是指同一方法根据发送对象的不同而采取不同的行为方式；一个对象的实际类型是确定的，但可以指向的对象的引用类型是不确定的。
多态是方法的多态！
多态存在的条件：
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
public class Person {
public void run(){
System.out.println("father");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void test(){
System.out.println("测试");
}
}
public class Demo6 {
public static void main(String[] args) {
//一个对象的实际类型是确定的
new Student();
new Person();
//一个对象可以指向的引用类型是不确定的
Student s1 = new Student();
//父类引用指向子类对象
Person s2 = new Student();
//Student子类可以调用自己或者父类的方法，如果子类重新了父类方法则调用子类里重写的方法
s1.run();//son
s1.test();//测试
//Person父类可以指向子类对象，但不能调用子类独有方法，且如果子类重新了父类方法则调用子类里重写的方法
s2.run();//son
//对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大!
}
}
