JAVA面向对象02
面向对象
private关键字
private 私有的
成员修饰符,只能修饰成员,不能修饰局部的
一个成员一旦私有,只能在本类中使用,外部类无法使用
私有的成员需要配合公共的访问方式一起使用–>方法
设置器 setter
访问器 getter
私有的属性配合公共的访问方式就能够实现安全么??
1.不能直接访问操作成员 2.设置器或者访问器中,方法中可以进行逻辑的判断等…
注意:
定义的模板类中的属性都要私有化,并提供一对公共的访问方式
public class StudentTest {
public static void main(String[] args) {
Student st = new Student();
st.setName("张三");
st.setAge(18);
st.setScore(100);
st.info();
}
}
class Student{
private String name;
private int score;
private int age;
public Student(){}
//设置器
public void setName(String name) {
this.name = name;
}
public void setScore(int score){
this.score = score;
}
public void setAge(int age){
this.age = age;
}
//访问器
public String getName(){
return name;
}
public int getScore(){
return score;
}
public int getAge(){
return age;
}
public void info(){
System.out.println("姓名:"+name+",年龄:"+age+",成绩:"+score);
}
}
封装
面向对象的三大特性: 封装 继承 多态
封装: 隐藏内部的实现细节,对外提供公共的访问方式
优点:
隐藏内部的实现细节,对外提供公共的访问方式
提高安全性
提高复用性
体现:
类,方法等都是封装的体现
属性私有化是封装的体现
私有是封装
封装不仅仅是私有
JAVABEAN 指代一些列类
代表模板类,根据对象抽取共性定义的类,统一称为javabean
定义javabean的规范:
1.类是公共的
2.至少提供一个空构造,按需提供带参
3.属性私有化
4.公共的访问方式
继承
面向对象的三大特性之一:继承
继承:子承父业
目的:为了提高代码的复用性
使用:子类 exyends 父类
派生类|子类:对象的抽象
超类|基类|父类:是对子类的抽象
子类一旦继承父类,就有权使用父类中的成员,被private修饰的成员,只能继承没有权限直接访问,可以通过父类中的设置器和访问器访问
构造函数不能被继承
子类是父类的延续(使用父类的内容)+扩展(定义子类独有的内容)
一个父类可以存在多个子类
单继承机制-> 一个子类只能存在一个父类
单继承:
优点:简单,提高代码的复用性
缺点:不够灵活,不便于后期维护,耦合度比较高
多实现->接口
面向对象的设计原则之一:开闭原则
为修改关闭,为扩展开放
public class ExtendsDemo01 {
public static void main(String[] args) {
Dog dog = new Dog("二哈",2,"哈士奇");
dog.run();
}
}
class Animal{
private String name;
private int age;
private String brand;
public Animal() {
}
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 String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public void run(){
System.out.println(name+"在飞快地奔跑...");
}
}
class Dog extends Animal{
public Dog(){
}
public Dog(String name,int age,String brand){
setName(name);
setAge(age);
setBrand(brand);
}
}
访问权限修饰符的权限范围
访问权限修饰符:某一个成员被访问的限定范围
访问权限修饰符 | 本类 | 同包下的类 | 不同包下的子类 | 不同包下的其他的类 |
---|---|---|---|---|
public | √ | √ | √ | √ |
protected | √ | √ | √ | |
default | √ | √ | ||
private | √ |
所有的访问权限修饰符都是成员修饰符,只能修饰成员,不能修饰局部(局部内容不能被外部访问)
能够修饰类的:public和default(默认的,省略不写,写上会报错)
当类或者成员前面不写权限修饰符的时候,默认为default,但是不能在前面直接写default
如果想要使用父类中继承的,被protected修饰的成员,需要在子类中并通过继承关系使用
私有的内容只能在本类中直接使用
package com.xxx.demo;
//本类
public class ModifierDemo {
public static int a;
protected static int b;
static int c;
private static int d;
protected int e;
public static void main(String[] args) {
System.out.println(ModifierDemo.d);//private
}
}
//同包下的类
class ModifierTest1 {
public static void main(String[] args) {
System.out.println(ModifierDemo.c);//default
}
}
package com.xxx.demo1;
import com.xxx.demo.ModifierDemo;
//不同包下的子类
public class ModifierTest2 extends ModifierDemo{
public static void main(String[] args) {
System.out.println(b);//protected,子类中继承直接调用
ModifierTest2 m2 = new ModifierTest2();
System.out.println(m2.e);//protected,子类中继承直接调用
ModifierDemo m = new ModifierDemo();
//System.out.println(m.e);//protected,子类中非继承直接调用,报错
}
}
package com.xxx.demo1;
import com.xxx.demo.ModifierDemo;
//不同包下的类
public class ModifierTest3{
public static void main(String[] args) {
System.out.println(ModifierDemo.a);//public
}
}