封装
基本介绍
- 该露的露，该藏的藏，我们的程序设计要追求“高内聚，低耦合”：
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉
- 低耦合：仅暴露少量的方法给外部使用
- 封装（数据的隐藏）：通常禁止直接访问一个对象中数据的实际表示，而因通过操作接口来访问，这称为信息隐藏
- 属性私有，get/set
- 为什么要使用封装：
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增强
- 方法的重载：如println()方法，按住Ctrl，然后鼠标点击该方法则可以查看具体内容
运用实例
FengZhuang.java
public class FengZhuang {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("李同洲");
System.out.println(stu1.getName());
stu1.setAge(999);//岁数不合法，我们可以在Student类中的setAge()中对age进行约束
System.out.println(stu1.getAge());
}
}
Student.java
//Student类 private:私有
public class Student {
//私有属性
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;
//提供一些可以操作这些私有属性的方法
//提供一些public的get和set方法
//get 获得这个数据
public String getName() {
return name;
}
public int getId() {
return id;
}
public char getSex() {
return sex;
}
//set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
public void setId(int id) {
this.id = id;
}
public void setSex(char sex) {
this.sex = sex;
}
public void setAge(int age) {
if (age>0&&age<120){
this.age = age;
}else{
this.age=3;
}
}
public int getAge() {
return age;
}
//学习（）
//睡觉（）
}
继承
基本介绍
- 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
- extands的意思是“扩展”，子类是父类的扩展
- Java中类只有单继承，没有多继承
- 继承是类与类之间的一种关系。除此之外，类与类之间还存在依赖、组合、聚合等关系
- 继承关系的两个类，一个是子类(派生类)，一个是父类(基类)。子类继承父类，使用extands来表示
- 子类和父类之间，从意义上讲应该具有“is a”的关系
- super注意点：
- super调用父类的构造方法，必须在构造方法的第一个
- super只能出现在子类或者构造方法中
- super和this不能同时调用构造方法
- this
- 代表的对象不同：this本身调用着这个对象；super：代表父类对象的应用
- 前提：this没有继承也可以使用；super只能在继承条件中使用
- 构造方法：this本类的构造；super父类的构造
- 方法重写：需要有继承关系，子类重写父类方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但是不可以缩小 （public>protected>default>private）
- 抛出的异常：范围可以缩小但是不可以扩大 （ClassNotFindException<Exception）
- 重写子类的方法必须和父类的方法一致；方法体不同
- 为什么要重写？（父类的功能子类不一定需要，或者不一定满足！）
运用实例
Test：JiCheng.java
public class JiCheng {
public static void main(String[] args) {
WoMen nv1=new WoMen();
System.out.println(nv1.money);
nv1.say();
System.out.println(nv1.getXing());
nv1.setXing("洲");
System.out.println(nv1.getXing());
//super
Man nan1=new Man();
nan1.text("li");
nan1.text2();
//静态方法
//方法的调用之和左边有关，定义的数据类型有关
B b=new B();
b.text();//B-->text()
A a=new B();
a.text();//A-->text()
//方法的重写（Override重写）
//非静态方法（非静态方法和静态方法是有很大的区别的）
B c=new B();
c.text();//B-->text()
//父类的引用指向了子类
A d=new B();//子类重写的父类的方法
d.text();//B-->text()
}
}
父类：Person.java
//在Java中，所有的类，都默认直接或者间接继承Object类
//父类
public class Person /*extends Object(可省略)*/ {
//public
//protected
//default
//private
public Person() {
System.out.println("Person无参");
}
/*public Person(String m) {
System.out.println("Person有参");
}*/
public int money=10_0000_0000;//如果属性为private则不能直接继承给子类
private String xing="李";//如果属性为private，需要通过get/set方法来获取数据，然后把get/set方法继承给子类
public void say(){
System.out.println("说话");
}
public String getXing() {
return xing;
}
public void setXing(String xing) {
this.xing = xing;
}
//super
public String name="litongzhou";
public void print(){
System.out.println("Person");
}
}
子类：WoMen.java
//女人 is 人：派生类 is 基类
//子类继承父类，就拥有父类的全部方法！
public class WoMen extends Person{
//Ctrl+h
}
子类：Man.java
public class Man extends Person {
//隐藏代码：调用了父类的无参构造
public Man() {
super();//调用父类的构造器，必须在子类构造器的的第一行
System.out.println("Man无参");
}
/*public Man() {
super("m");
System.out.println("Man有参");
}*/
//super
private String name="李同洲";
public void text(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
public void print(){
System.out.println("Man");
}
public void text2(){
print();
this.print();
super.print();
}
}
父类：A.java
public class A {
//重写都是方法的重写，和属性无关
public void text(){
System.out.println("A-->text()");
}
}
子类：B.java
public class B extends A{
//Override重写
@Override //注解：有概念的注解
public void text() {
System.out.println("B-->text()");
}
}
