封装和继承
访问修饰符
- 访问修饰符可以修饰类、方法或者变量，通常放在语句的最前端
- 访问修饰符就是定义类、方法和变量可以被调用的范围
- 默认修饰符可以在类上使用，同包下可以继承，不同包下不可以继承
- protected private 修饰符不能在类上使用，在类上只能使用public 和默认修饰符
- 默认修饰符可以用在构造方法上，继承时同包下可以，不同包下不可以
- protected可以用在构造方法上，继承时同包下可以，不同包下不可以
- private可以用在构造方法上，继承时不能被子类用，只能在本类使用，可以提供一个静态方法供调用者使用（单例模式）
/*访问修饰符:可以修饰变量，方法，类
修饰变量：四种修饰符都能使用
修饰方法：四种修饰符都能使用
修饰类：2种 public,default */
//名字 范围
同类 同包 子类 不同包
private V X X X
默认 V V X X
protected V V V X
public V V V V
封装
- 定义：将类的属性私有化隐藏起来（使用private修饰），让外部不能随意的访问属性和赋值，只能使用类提供的公开的get和set方法进行属性赋值和访问
- 优点：减少程序的耦合；可以对成员变量进行更精确的控制，定义赋值的合法性
封装的步骤：
1.使用private进行修饰成员变量，将属性私有化
2.提供公开的get/set方法
public class Student {
//第一步，属性私有化，使用private修饰属性
private String name;
private int age;
private String gender;
//提供无参 有参构造
public Student() {
super();
}
public Student(String name, int age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
//第二步，提供公开的（public修饰的）的get/set方法
//可以对属性的合法性进行判断，合法才进行赋值，比如判断年龄不能为负数
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<0){
System.out.println("年龄不能为负数");
}else{
this.age = age;
}
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
使用：
1：创建对象
2：通过get/set方法进行赋值
public class test111 {
public static void main(String[] args) {
//创建对象
Student stu = new Student();
//stu.age = 18; 类封装后不能再通过这种方式进行赋值
//通过set方法进行赋值
stu.setAge(18);
stu.setGender("女生");
stu.setName("韩梅梅");
//通过get方法调用
System.out.println("我叫"+stu.getName()+"是"+stu.getGender()+"今年"+stu.getAge()+"岁");
}
}
继承
- 子类可以继承父类非private和默认修饰符（不同包时）所修饰的属性和方法；子类也可以重写父类的方法；同时子类也可以有自己的属性和方法
- JAVA中继承是单继承，一个子类只能继承一个父类，但是一个父类可以有多个子类
- 在Java中，所有的类都直接或者间接继承Object类
- 继承的优点，抽取子类相同的属性和方法，子类直接继承父类，可以减少代码量
- 调用子类构造创建子类对象时，会自动先创建父类对象
- 子类通过extends关键字,实现继承
继承格式
class 父类 {
}
class 子类 extends 父类 {
}
父类
public class Animal {
private int age;//年龄
private String uname;//名字
private int gender;//性别
private String type;//品种
public Animal() {
super();
System.out.println("这是父类的无参构造");
// TODO Auto-generated constructor stub
}
public Animal(int age, String uname, int gender, String type) {
super();
System.out.println("这是父类的有参构造");
this.age = age;
this.uname = uname;
this.gender = gender;
this.type = type;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public int getGender() {
return gender;
}
public void setGender(int gender) {
this.gender = gender;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public void print() {
System.out.println("名字是："+uname+",年龄是："+age);
}
}
子类
//子类继承父类
public class Pig extends Animal{
private double price;//子可以有类自己的属性 价钱
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
测试
Pig pig = new Pig();
pig.setUname("小朱");
pig.setAge(2);
pig.setGender(1);
pig.setType("中华田园猪");
pig.setPrice(33.0);//子类自己的方法
知识点
- 1：如果子类构造方法默认的时候，会默认调用父类无参构造，如果没有写，java编译的时候会自动添加super()到第一行
- 2：调用父类构造方法时，super必须放在第一行
- 3：继承过来的属性大家共用了
- 4：如果子类没有重写父类方法 方法名();this.方法名();super.方法名();三种调用方式结果一样
- 5：super可以被用在构造方法上，也可以被用在普通方法上,但在普通方法里面不能直接调用super();
- 6：this和super的区别，this代表自己 super代表父亲
- 7：如果没有直接在代码里写出继承关系，默认继承Object
- 静态方法里面不能使用 super和this
super 关键字
访问父类的方法。
调用父类构造方法。
访问父类中的隐藏成员变量。
