Java日记（6）— 面向对象特性
来源：互联网 发布：wear软件下载 编辑：程序博客网 时间：2024/06/05 16:32
1.封装：
将实体特性的属性隐藏起来，对象对外界仅通过公共方式进行交流，这样可以提高程序的可读性，安全性，改善程序的可维护性。 数据的隐藏与开放对外的接口可以通过访问权限控制符来实现，权限控制符可以用来设置类，成员变量，成员方法等的访问权限。java提供public，protected，private和默认等4种访问控制符，在类，成员变量，成员方法的前面均可使用访问控制符关键字。 没有显式使用的为默认控制类型。
public：
public访问权限最具有开放性，可以用来修饰类，类与接口的成员（包括成员变量，成员方法）。- public修饰的类或类成员可以被任何类访问，他们既可以位于同一个包中，也可以位于不同包中。
- 修饰为public的类可以被任何其他类及成员方法访问和引用。java文件名应与修饰为public的类名相同.
- 修饰为public的类成员和方法，可以在其他类中无限制地访问该成员。
- 为了保证数据的隐藏性和安全性，通常只将公共类或公共接口的成员方法指定为public
protected：
protected可以用来修饰类的成员变量或方法（<b>注意不能修饰类</b>）。- 被protected修饰的类成员可以被本类，本包中的其他类访问。
- 被protected修饰的类成员可以被子类继承（不管子类是本包还是其他包，都可以被子类访问）
默认：
如果在定义类，接口，成员变量，成员方法时都没有指定访问权限控制符，他们的权限即为默认权限。- 具有默认权限的类，接口，成员（包括成员变量和成员方法），只能被本类和同一个包中的其他类，接口及成员方法引用。因此默认权限也成为包权限
private：
私有访问控制符private用来声明类的私有成员（变量或方法）。- 用private修饰的成员变量或方法只能被类自身所访问和修改，而不能被任何其他类（包括该类的子类）来获取和引用
代码：
Example_5包：
import course.*;public class Example_5_10 { public static void main(String[] args) { Examination exam; Student1 zhanggang = new Student1(19,"山西太原","张刚",350); //??具有默认权限的类，接口，成员（包括成员变量和成员方法），只能被本类和同一个包中的其他类，接口及成员方法引用。因此默认权限也成为包权限 //解决方案：当Example_5_10不属于任何一个包的时候（即显示default package）代码可以运行，若Example_5_10属于包,报错 Teacher missLiu = new Teacher(35,"beijing","刘老师",2000,"102198"); //??同上 ComputerCourse c1 = new ComputerCourse(missLiu,"12345",3.5f,"必修","Java程序设计基础","5"); c1.putInfo(); exam = new Examination(zhanggang,c1,55f); exam.putCredit(); System.out.println(); }}class Examination{ Student1 student; float score; course course; public Examination(Student1 student,course course,float score){ this.student=student; this.course=course; this.score=score; } public float putCredit(){ float c=0.0f; if(score >=60){ c= course.credit; System.out.println("通过考试，实际学分为："+c); } if(score<60) { c=0; System.out.println("未通过考试，实际学分为："+c); } //System.out.println("课程性质"+course.courseCharacter); //普通类不能访问不同包中类的protected类型，对比下面第51行代码 return c; }}class ComputerCourse extends course{ Teacher teacher; public ComputerCourse(Teacher teacher,String courseID,float credit,String courseCharacter,String description,String term){ super(courseID,credit,courseCharacter,description,term); this.teacher = teacher; } public void putInfo(){ System.out.println("课程编号"+courseID); System.out.println("学分："+credit); System.out.println("课程性质"+courseCharacter); //System.out.println("开设学期："+term); term为private权限，不可被不同包的子类访问 //System.out.println("课程介绍："+description); description为默认权限，不可被不同包的子类访问 }}course包：
package course;public class course { public String courseID; public float credit; protected String courseCharacter; String description; private String term; public course(){} public course(String courseID,float credit,String courseCharacter,String description,String term){ this.courseCharacter = courseCharacter; this.courseID = courseID; this.credit = credit; this.description = description; this.term=term; }}class Student1{ public int studentAge; //public protected String studentAddr; //protected String studentName; //默认 private int studentAccount; //private public Student1(int studentAge,String studentAddr,String studentName,int studentAccount) { this.studentAccount = studentAccount; this.studentAddr = studentAddr; this.studentAge = studentAge; this.studentName=studentName; } public Student1(){ this.studentAge = 18; }}class Manger extends Student1{ void getStudentInformation(){ System.out.println("name is "+studentName); System.out.println("age is "+studentAge); //System.out.println("account is "+studentAccount); System.out.println("addr is "+studentAddr); }}class Teacher{ public int age; //public protected String addr; //protected String name; //默认 private int account; //私有 String teacherID; //默认 public Teacher(int age,String addr,String name,int account,String teacherID) { this.age=age; this.addr=addr; this.name=name; this.account=account; this.teacherID = teacherID; } public void SetInfo(String teacherID){ this.teacherID = teacherID; } public void question(Student1 s){ System.out.print(s.studentAddr +"\t"+s.studentAddr+"\t"+s.studentName); //System.out.println("\t"+s.studentAccount); }}插入：
1.import导入的是类（或者说导入的是.class文件，因为只有类声明为public才能被不同包中的普通类（不考虑protected和继承）访问，并且当在一个.java文件中声明了多个类，那么系统会生成多个.class文件，文件名为各自类的名称），而不是导入的包（目录）
2.package.*表示导入该包中的所有类，也就是平常所说的导入包
3.如何理解和使用java package包
4.java中package和import
5.JDK和JRE目录的文件结构
6.java JRE与JDK的区别
2.继承：
格式：class 子类名 extends 父类名 [implements <接口名>]{}说明：
Java使用关键字 extends 来实现类的继承，如果类定义时没有使用extends关键字，则默认该类的父类是java.lang.Object类。Object类是所有预定义类的父类，包含了所有java的公共属性（想看有哪些的话，可以百度，可以看源码，也可以自己在程序里面创建个对象实例看看）。其中定义的属性和方法均可以被任何类使用，继承或修改。
java规定不允许多重继承，即extends后面只能有一个父类
代码一：
package package2;public class Example_5_12 { public static void main(String[] args) { Manager mrZhang = new Manager(); mrZhang = new Manager(); mrZhang.setName("张刚"); mrZhang.setDepartment("教务处"); mrZhang.setSalary(2500); mrZhang.setSpecial("教务处处长"); mrZhang.setSubsidy(500); System.out.println("**************************员工信息*******************"); System.out.println(); System.out.println(mrZhang.toString()); Employee employee1 = new Manager(); //父类的对象指向子类 System.out.println(employee1.toString()); //调用子类的方法 }}class Employee{ protected String name; protected double salary; protected String department; //setInfo方法 public void setName(String name){ this.name=name; } public void setSalary(double salary){ this.salary = salary; } public void setDepartment(String department){ this.department = department; } //getInfo方法 public String getName(){ return name; } public double getSalary(){ return salary; } public String getDepartment(){ return department; } // public String toString(){ return "姓名："+name+"\t部门："+department+"\t 基本工资"+salary; }}class Manager extends Employee{ //Manager继承父类Employee private String special; private double subsidy; //setInfo方法 public void setSpecial(String special) { this.special = special; } public void setSubsidy(double subsidy){ this.subsidy = subsidy; } //getInfo方法 public String getSpecial(){ return special; } public double getSubsidy(){ return subsidy; } // public String toString(){ return "姓名："+name+"\t 部门"+department+"\t 职务："+special+"\t 基本工资："+salary+"\t 津贴："+subsidy; }}代码二（super的用法）：
子类在集成父类时，可能出现变量隐藏，方法覆盖（Overriding)等现象。
变量隐藏：子类的成员变量与父类成员变量同名时；此时，父类的成员变量被隐藏。
方法覆盖：子类的方法与父类的相同（相同指方法的返回值类型，入口参数的一切（数目，类型，顺序）均相同，只是方法实现的功能不同；此时，父类的方法被覆盖）
如果子类想要调用被隐藏的变量或者覆盖的方法时，就需要用super实现。
package package2;public class Example_5_13 { public static void main(String[] args) { AClass aClass = new AClass(); BClass bClass = new BClass(); aClass.p1(); bClass.p1(); //父类对象引用子类 AClass a = new BClass(); a.a=100; a.p1(); }}class AClass{ int a; float a1; public AClass(){ a=50; a1=99.99f; } public void p1(){ System.out.println("this is method of A"); System.out.println("a="+a); }}class BClass extends AClass{ int a; //与父类变量名相同，属于变量隐藏现象 public BClass(){ a=10; a1=123.6f; } public void p1(){ //与父类的成员方法相同，属于方法覆盖现象 System.out.println("this is a method of B"); System.out.println("a="+a); //此处a是BClass的变量值 super.p1(); //通过关键字super调用被覆盖的父类的成员方法 System.out.println("spuer.a="+super.a); //通过super关键字访问被隐藏的父类成员变量 }}代码三：
super还可以调用父类的构造方法。package package2;public class Example_5_15 { public static void main(String[] args) { @SuppressWarnings("unused") Doctor d = new Doctor("wang",1,"wu"); }}class Doctor{ String name; int ID; String address; public Doctor(String name,int ID,String address) { this.name = name; this.ID =ID; this.address =address; System.out.println("名字："+name); System.out.println("编号："+ID); System.out.println("地址："+address); } public Doctor(){} //如果不定义该无参构造方法，将导致A行错误}class Specialist extends Doctor{ public Specialist(String name,int ID,String address){ super(name,ID,address); } public Specialist(){ super(); //A行，由于父类提供了有参构造方法，系统不提供默认的无参构造方法 name = "10"; }}调用父类的构造方法的规则：
- 创建对象时调用该类的父类构造方法。调用父类的构造方法步骤是：只要在子类的构造方法中第一条语句为super就行，super可以调用父类的任何一个构造方法
- 如果类中的构造方法中第一条语句没有用super调用父类的构造方法，则编译器会默认用super调用父类的无参构造方法（注意上面代码的提示）
- 如果某个类的构造方法的第一条语句用this调用本类的其他构造方法，则不会再本构造方法中调用父类的构造方法（在this调用的构造方法中调super。）
代码四 ：对象类型转换（C++的虚函数，但是语法比C++简单）：
package package2;public class Example_5_16 { public static void main(String[] args) { C c = new D(); //父类引用指向子类对象 c.n =3.1415926; //修改的是父类引用的被隐藏对象; //c.w=300; //Error，父类引用不能操作子类对象新增的成员变量 //c.cry(); //Error,父类引用不能操作子类对象新增的成员方法 c.m=186; c.f(); c.g(); //指向的是一个子类对象，因此调用的是子类的g()方法 // c = new C(); //A行 // c.g(); D d=(D)c; //将c强制转换为子类对象，然后赋值给d ； 只有父类引用指向子类对象时，才能强制转换，若有A行，则本行报错 d.n = 555; d.f(); d.g(); d.cry(); }}class C{ int m; double n; void f(){ System.out.println("被子类继承的方法f()"); } void g(){ System.out.println("你好，n="+n+"m="+m); }}class D extends C{ int n=12; int w; void g(){ System.out.println("子类重写方法g(),n="+n+"m="+m); } void cry(){ System.out.println("子类新增方法"); }}3.多态:
代码：
package package2;public class Example_5_18 { public static void main(String[] args) { Lady missLiu = new Lady(); missLiu.pet = new Dog2(); missLiu.petEnjoy(); Lady missWang = new Lady(); missWang.pet = new Bird(); missWang.petEnjoy(); }}class Lady{ Pet pet; void petEnjoy(){ pet.enjoy(); }}class Pet{ int name; void enjoy(){ System.out.println("宠物高兴"); }}class Bird extends Pet{ void enjoy(){ System.out.println("喳喳。。。。。。。。。。"); //方法覆盖 }}class Dog2 extends Pet{ void enjoy(){ System.out.println("汪汪。。。。。。。。。。"); //方法覆盖 }}阅读全文
0 0
- Java日记（6）— 面向对象特性
- Java面向对象特性
- Java面向对象特性
- Java面向对象特性
- Java面向对象特性
- Java面向对象特性
- JAVA面向对象特性
- 面向对象特性总结（Java）
- java面向对象特性（续）
- 【java】面向对象（三大特性）
- 黑马程序员—java面向对象总结（3）—面向对象继承、多态特性
- Java的面向对象特性
- Java的面向对象特性
- Java的面向对象特性
- 【Java基础】面向对象特性
- java-基础-面向对象特性
- Java中的面向对象特性
- java面向对象的特性
- sql基本语句
- Android Gradle使用详解
- 监听器？
- 经过了多种方法的尝试，终于找到Quartus破解成功但是没有办法编译的解决方法
- 如何用最简单的方式解释依赖注入？依赖注入是如何实现解耦的?
- Java日记（6）— 面向对象特性
- [Kotlin]Kotlin二进制读写
- CSDN-markdown编辑器
- struts2+ajaxfileupload.js实现单文件传输
- 从MySQL数据库读取图片和向数据库插入图片
- HDOJ HDU 1113 Word Amalgamation
- Unity3D中在Inspector面板中显示复合属性信息（类属性/Struct属性）
- 使用superlance插件增强supervisor的监控能力
- No package python-pip available. 解决方法
