封装
-
该露的露，该藏的藏
我们的程序设计要追求"高内聚，低耦合"。高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
-
封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称作信息的隐藏
-
属性私有，get/set
封装的特点：
-
1.提高程序的安全性，保护数据 2.隐藏代码的实现细节 3.统一接口 4.系统可维护增加
代码：
package com.oop;
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加
*/
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("施刚龙");
System.out.println(s1.getName());//施刚龙
s1.setAge(21);
System.out.println(s1.getAge());
}
}
package com.oop;
//类 private:私有
public class Student {
//属性私有
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;//年龄
//提供一些可以操作这些属性的方法!
//提供一些public的get和set方法
//get获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
public int getId(){
return this.id;
}
public void setId(int age){
this.id = id;
}
public char getSex(){
return this.sex;
}
public void setSex(char sex){
this.sex = sex;
}
public int getAge(){
return this.age;
}
public void setAge(int age){
if (age>120 || age<0){
this.age = 3;
}else {
this.age = age;
}
}
}
继承
- extends关键字
- Java类只有单继承，没有多继承
- 继承关系的两个类：一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends。
- Object类，super关键字，方法的重写
- 被final定义的类不能被继承（记住就可了）
代码：
package com.Demo01;
//Java中，所有的类都默认直接或间接继承Obje类
//Person 人:父类
public class Person {
//public
//protected
//default 默认
//private
public int money = 1000000000;
public void speak(){
System.out.println("hello大家好");
}
public int getMoney(){
return this.money;
}
public void setMoney(int money){
this.money = money;
}
}
package com.Demo01;
public class Student extends Person{
}
package com.Demo01;
public class Teacher extends Person{
}
package com.Demo01;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.speak();
System.out.println(student.money);//1000000000
student.setMoney(10000);
System.out.println(student.getMoney());//10000
Person person = new Person();
}
}
super 关键字
注意点：
- super调用父类的构造方法，必须在构造方法的第一个！！！
- super 必须只能出现在子类的方法或者构造方法中
- super和this 不能同时调用构造方法
VS this：(指向自己的引用）
-
代表的对象不同：
- this：本身调用者这个对象
- super：代表父类对象的应用
-
前提：
- this：在没有继承也可以使用
- super：只能在继承条件下才可以使用
-
构造方法
- this()：调用本类的构造
- super()：调用父类的构造
代码：（不会多看!!!）
package com.Demo01;
public class Application {
public static void main(String[] args) {
Student student = new Student();//自动调用无参构造
//Student student = new Student(22);//传入参数调用有参构造方法
student.test("秦疆");
student.test1();
}
package com.Demo01;
public class Student extends Person{
private String name = "施刚龙";
public int age;
public void test(String name){
System.out.println(name);//秦疆
System.out.println(this.name);//施刚龙
System.out.println(super.name);//狂神
}
public void print(){
System.out.println("Student");
}
public void test1(){
print();//Student
this.print();//Student
super.print();//Person
//super.hello();//私有的东西无法继承
}
public Student(){
//默认调用了父类的无参构造，super()可以不写
super();//调用父类的构造器，必须在子类构造器的第一行
//this();//调用有参构造方法，传入"hello"
System.out.println("Student无参构造执行了");
}
public Student(int age){//通过this()调用，但this()和super()不能同时调用构造方法
super(21);
this.age = age;
System.out.println(this.age);
System.out.println("Student有参构造执行了");
}
}
package com.Demo01;
//Java中，所有的类都默认直接或间接继承Object类
//Person 人:父类
public class Person {
protected String name = "狂神";
public int age;
public void print(){
System.out.println("Person");
}
//私有的东西无法被继承
private void hello(){
System.out.println("Hello");
}
public Person(){
System.out.println("Person无参构造执行了");
}
public Person(int age){
this.age = age;
System.out.println(this.age);
System.out.println("Person有参构造执行力");
}