package day04;
/*
封装：属性设置为private的，封装在类的内部，对外提供public的get/set方法供外部调用。
好处：在类内部对参数做一些限制，防止非法的调用。
*/
public class Demo01 {
public static void main(String[] args) {
Student s1 = new Student("zhangsan",18,90);
System.out.println(s1);
//在类的外部可以访问到属性。
s1.name = "张三"; //设置获取属性，实例，属性名
s1.score = 99; // 0~150
System.out.println(s1);
//设置的分数不合理，也能设置
s1.score = -500;
System.out.println(s1);
Student1 s2 = new Student1("lisi",18,90);
System.out.println(s2);
//s2.name = "李四"; //私有的属性在外部无法访问
//s2.score = 99;
s2.setScore(100);
System.out.println(s2.getScore());
s2.setAge(2);
System.out.println(s2.getAge());
}
}
//未封装
class Student{
String name;
int age;
float score;
public Student(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
//封装后的
class Student1{
private String name;
private int age;
private float score;
//获取属性值
public int getAge(){
return age;
}
//设置属性值
public void setAge(int a){
if ( a < 3 || a > 30 ){
System.out.println("你输入的参数不合法");
}else {
age = a;
}
}
//获取属性的值
public float getScore(){
return score;
}
//设置属性的值
public void setScore(float s){
if ( s < 0 || s > 150 ){
System.out.println("参数不合法");
}else {
score = s;
}
}
public Student1(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Student1{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
//封装后的，
//getter setter 可以用IDE自动生成：右键Generate
class Student2{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
private float score;}
package day04;
/*，
继承：使用extends关键字，继承父类的属性和方法，不继承构造方法
没有显式写extends时，默认是从object继承的
每个类只能有一个父类，但是可以有多层的关系，比如用一个父类，一个祖父类，曾祖父类......
子类除了继承父类的属性和方法，也可以有自己的属性和方法。
重写override、重载overload的差别
重新：子类重写父类同名的方法。
重载：
*/
public class Demo02 {
public static void main(String[] args) {
Dog dog = new Dog("小黑",11,100);
System.out.println(dog);
dog.setHealth(90); //继承了父类的方法
System.out.println(dog.getHealth());
Dog dog2 =new Dog("拉布拉多",5,100,"白色");
System.out.println(dog2); //Pet toString
}
}
class Pet{
private String name;
private int age;
private int health;
public Pet(String name, int age, int health) {
this.name = name;
this.age = age;
this.health = health;
}
@Override
public String toString() {
return "Pet{" +
"name='" + name + '\'' +
", age=" + age +
", health=" + health +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
}
/*
创建一个宠物类，pet
属性：string name，age，health
tostring（） 构造方法 set/get方法
*/
/*
宠物狗从宠物类继承：从父类继承属性和方法，不继承构造方法
*/
class Dog extends Pet{
private String color;
public Dog(String name, int age, int health, String color) {
super(name, age, health);
this.color = color;
}
public Dog(String name, int age, int health) {
//super 超类/父类,调用父类的构造方法
super(name, age, health);
}
@Override
public String toString() {
return "Dog{" +
"color='" + color + '\'' +
"} " + super.toString();
}
}
|
