Java面向对象学习笔记(第七篇[ps:本章涉及的内容为面向对象的三大特征(封装、继承、多态)])
- 包:
概念:物理上是文件夹,管理类
作用:1.避免类重名 2. 按照不同的功能管理类 3. 控制访问权限
命名规范:在包名中,可以使用.号来区分包的级别;包名一般情况下是小写
第一级 指该项目的类型,如com,org,gov等,
第二级 指项目所开发或者运行的公司名称,如:oracle,sun,huawei等
第三级 指项目的名称,如:bcms,oa,erp,cms等
第四级 指项目模块的名称,如:bean,action,exception等
(包可以更好的管理逻辑相关的类,可以控制不同包之间的访问权限,一般要用import来导入外部包的类) - 访问权限修饰符:
1.public(公共权限):修饰类、属性、方法。可以被任意类访问
2.default(同包权限,默认可以不写):修饰类、属性、方法。只能被同包的类访问
3.protected(受保护的权限):修饰属性方法。可以被同包类访问,如果不是同包类,必须是该类的子类才可以访问。
4.private(私有权限):修饰属性、方法。只能在本类中访问。
import java.util.Date;
/*
包的作用:1.避免类同名
2.按照不同功能管理类
3.控制访问权限
*/
public class Dome1 {
//同一个包下不可引用相同类名
public static void main(String[] args) {
Date d = new Date();
//如果要引用同类名的类,则需要写全类名
java.sql.Date D = new java.sql.Date(1000);
}
}
public class Dome2 {
int num; //默认 修饰类、属性、方法,可以在同一个包类被访问
public int pnum;//公共 修饰类、属性、方法,可以在同一个包类被访问,也可以跨包访问
protected int pronum;//受保护 修饰属性、方法,可以在同一个包内被访问,跨包必须是其子类才可被访问
private int prinum;//私有类 修饰属性,方法,只可以在同一个包内被访问
public void text(){
this.num = 1;
this.pnum = 2;
this.pronum = 3;
this.prinum = 4;
}
}
public class Dome3 {
public static void main(String[] args) {
Dome2 dome2 =new Dome2();
System.out.println(dome2.num);
System.out.println(dome2.pnum);
System.out.println(dome2.pronum);
// System.out.println(dome2.prinum);
}
}
面向对象三大特征(封装、继承、多态)
1.**封装**:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问 封装的优点:1.隐藏类的实现细节。2.方便加入控制语句。3.方便修改实现.现。4.只能通过规定方法访问。public class Person {
//定义私有属性进行封装
private String name;
private int age;
// 定义无参的构造方法
public Person(){
}
// 定义成员方法来对私有的属性进行操作
public void setName(String n){
if (n!=null){
this.name = n;
}
}
// 定义方法来返回一个属性
public String getName(){
return this.name;
}
public void setAge(int a){
if(a>0){
this.age = a;
}
}
public int getAge(){
return age;
}
}
public class person_text {
public static void main(String[] args) {
Person p = new Person();
p.setName("乔峰");
p.setAge(18);
int a = p.getAge();
a+=12;
System.out.println(a);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}
2.继承:在已有类的基础上派生出新的类,新类可以拥有父类所有非私有属性和非私有方法。
作用:可提高代码的重用性和可扩展性。
public class Animal {
private String name;
private int age;
public Animal() {
System.out.println("父类的无参的构造方法");
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
System.out.println("父类的有参构造方法");
}
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 void eat(){
System.out.println("觅食");
}
}
@后面的一般都是Java注解,是Java中事先定义好的注解标签,作用在类、属性、方法上,用于标记。运行/编译时进行解析检测
@override重写 是在继承的时候,如果你写的函数与要继承的函数函数特征相同,
那么,加上这个关键字,在使用这个子类的这个函数的时候就看不见父类(或超类)的函数了,它被覆盖掉了。
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃老鼠");
}
}
public class Dog extends Animal {
private String type;
public Dog(){
super();
System.out.println("子类的无参构造方法");
}
public void run(){
super.setName("老帮主");
System.out.println("跑的快");
}
public void eat(){
System.out.println("敢吃屎");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.setName("乔峰");
System.out.println(dog.getName());
dog.eat();
dog.run();
System.out.println(dog.getName());
Cat cat = new Cat();
cat.eat();
}
}
类之间的关系(关联,依赖)
关联关系:即“有”的关系(has - a)对象和对象直接的连接。关联关系分为单项关联和双向关联,单向关联即为A类关联B类;双向关联为A类关联B类且B类也关联A类。
关联关系的多重性:
1.一对一关联关系:例如:一个学生只能在一个班级里学习
2.一对多关联关系:例如:一个学生可以参加多个班级学习
依赖关系:(use - a)即一个类A使用到了另一个类
依赖关系的特性:这种关系时偶然性的、临时性的、非常弱的,但是类B的变化会影响到类A。
public class Preson {
//人类和手机的关联关系 has-phone
private String name;
// private Phone phone;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// public Phone getPhone() {
// return phone;
// }
// public void setPhone(Phone phone) {
// this.phone = phone;
// }
//人类和手机的依赖关系 use-phone1
public void use(Phone phone1){
// this.phone = phone1;
System.out.println(name+"会使用"+phone1.getType());
}
}
public class Preson_Test {
public static void main(String[] args) {
Preson p1 = new Preson();
Phone p2 = new Phone();
p1.setName("乔峰");
p2.setType("菲尔普斯山寨机");
p1.use(p2);
}
}
3.多态:同一种事务,在不同时刻表现不同的状态
多态存在的三个必要条件:1.要有继承(包括接口的实现)(前提条件)2.要有重写(前提条件)3.父类引用指向子类(父类名 变量名 = new 子类名)
抽象类:(类中有未实现功能的方法)被abstract修饰的类
如果一个类中含有抽象方法(没有实现的方法),那么这个类一定是抽象类;如果一个类是抽象类,它不一定要有抽象方法;如果一个类继承类抽象类:要么重写抽象类中的所有抽象方法。要么把当前类也声明为抽象类
public abstract class Animal {
private String name;
private int age;
public abstract void eat(Animal animal);
public static void run(Animal animal) {
System.out.println("能跑");
}
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 class Cat extends Animal{
@Override
public void eat(Animal cat) {
System.out.println("猫吃鱼");
}
public void ming(){
System.out.println("猫有九条命");
}
}
public class Dog extends Animal{
private Animal type;
@Override
public void eat(Animal dog) {
System.out.println("狗吃屎");
}
public void samell(){
System.out.println("千里追踪,万里无极");
}
}
public class Test {
public static void main(String[] args) {
Animal dog = new Dog();
Animal cat = new Cat();
dog.setName("乔峰");
System.out.println(dog.getName());
dog.eat(dog);
Animal.run(dog);
cat.setName("老帮主");
if(cat instanceof Cat) {
Cat cat1 = (Cat) cat;
cat1.ming();
}else {
System.out.println("cat不包含Cat类型");
}
if(dog instanceof Dog) {
Dog dog1 = (Dog) dog;
dog1.samell();
}
else{
System.out.println("dog不包含Dog类型");
}
}
}
final 用于声明属性、方法和类
修饰属性是时:定义了就必须直接赋值或者在构造方法中进行赋值,一般将其修饰为static,节省了空间,所有对象共享一份。(finla修饰的类不能被其他类继承)
//final定义修饰的类不能被其他类继承
public final class Pig{
//final定于的属性为常量,定义时必须赋值或者在构造方法中赋值,一般将其修饰为static,节省了内存空间,所有对象共享一份
final static String type = "荷兰香猪";
final int time;
public Pig(int time){
this.time = time;
}
//final修饰的方法不能被其他方法重写(覆盖)
public final String eat(){
String str = "爆烤的荷兰烤乳猪很香";
return str;
}
public static void main(String[] args){
Pig p = new Pig(1);
System.out.println("经过"+p.time+"个小时"+p.eat());
}
}