学习体会"/>
JavaOOP(面向对象)学习体会
JavaOOP(面向对象)学习体会
类和对象的概念
- 类:具体相同特征和行为的事物的抽象
- 对象:万事万物皆对象
- 类是对象的类型!
- 对象是类的实例 !
封装
//特征---->属性(特性)String name;int age;String[] hobbys;
//行为--->方法(函数)public void run() {System.out.println("奔跑吧鼠宝宝!");}
运行只能在main函数中运行
public class Main {public static void main(String[] args) {Person person = new Person();//创建对象才能调用类中的方法person.run();}
}
属性的可见度
public 公开的,任何包中任何类中都可以访问到此属性!不符合封装特性!
protected 受保护的,本类及其子类和同包中可以访问!
private 私有的,仅本类可以访问!(常用写法)
- 创建一个Girl类如下
public String name;
protected int age;
private String phoneNumber;
注意:属性私有化在外界无法访问!
需要借助setter和getter方法
//存值方法
public void setPhoneNumber(String phone) {//注意 此时的phone的是形参!phoneNumber = phone;
}
//取值方法
public String getPhoneNumer() {return phoneNumber;
}
在Main类中测试
package com.a;
public class Main {public static void main(String[] args) { Girl myGirl = new Girl();myGirl.name = "Aurora";myGirl.age = 18;//myGirl.phoneNumber = "12038520107";//传值myGirl.setPhoneNumber("12038520107");System.out.println(myGirl.getPhoneNumer());}
}
setters和getters方法
构造方法(带参构造 无参构造)
toString方法,重写的对象的输出方式
必须私有化属性才能写setters和getters方法
alt+shift+s 快捷提示方法
public class Student {private int num;private String name;private String sex;private int age;//构造方法----(初始化方法)public Student() {//无参数 构造方法}//带参构造方法public Student(String name, int num, String sex, int age) {this.name = name;this.num = num;this.sex = sex;this.age = age;} //注意:以上两个构造方法 在今后开发中都会补充完整!public int getNum() {return num;}public void setNum(int num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {this.age = age;} @Override//重写对象的输出方式 默认输出的是对象在内存中的地址public String toString() {return this.num + " " + name + " " + sex + " " + age;}
}
在main主函数中测试
public class Main {public static void main(String[] args) {Student stu1 = new Student();//午餐System.out.println(stu1.getName() + " " + stu1.getSex() + " " + stu1.getAge());Student stu2 = new Student("雯雯", 2, "boy", 18);//有参System.out.println(stu2.getName() + " " + stu2.getSex() + " " + stu2.getAge());Student stu3 = new Student("超超", 3, "boy", 18);System.out.println(stu2);System.out.println(stu3);}
}
this 指代当前调用本方法的对象
this.name 可以理解为 对象.name
static 静态关键字
static 修饰的属性和方法 由类名直接调用!!!!
super 编译指令,指向父级
final 关键字,修饰类,会阻断继承! 修饰方法,方法将不能被重载!
方法的重载(方法名一致,参数不一致)
方法名一致!但是参数不同!
public class Cat {public void run() {System.out.println("黑猫警长!嘿嘿!");}public void run(String name) {System.out.println(name + "吃肉吗?四块够吗?" );} public void run(String name, int count) {System.out.println(name + count + "块够了够了!xx真好,谢谢xx!嘿嘿");}
}
测试
public class Main {public static void main(String[] args) {Cat cat = new Cat();cat.run("棒槌");cat.run();cat.run("大棒槌", 8);}
}
创建了一个Mouse类
private String name;//对象级属性,由对象调用//由对象调用public void eat() {System.out.println(this);//System.out.println(name+"小老鼠,偷吃糖!在磨牙!");}...Mouse mouse = new Mouse();mouse.eat();
private static String color;//类级属性,由类名直接调用!
//由类名直接调用
public static void run() {//注意注意!!!在静态方法中,不可以使用this//因为本方法由类名直接调用,会跳过对象!!System.out.println("别跑!让阿凯养了你!");
}
...
Mouse.run();
继承
extends 继承的关键字!!!
public class 本类名 extends 父类名{
}
继承的特点:
- 继承的单向的
- 正常的继承一个类只能有一个父类!
- 子类继承父类的方法和属性
- 子类可以新增方法和修改父类中继承来方法
创建一个Person类作为父类
public class Person {private String name;private String sex;private int age;public Person() {}public Person(String name, String sex, int age) {this.name = name;this.sex = sex;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";}
}
创建一个Student类作为子类
public class Student extends Person{private int num;private double score;//但是怎么给属性赋值呢?public Student() {}//在子类中 构造方法的写法 必须重写public Student(String name, String sex, int age,int num, double score) {super(name, sex, age);this.num = num;this.score = score;}//-------------------------------------public int getNum() {return num;}public void setNum(int num) {this.num = num;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}@Overridepublic String toString() {return "Student [num=" + num + ", score=" + score + ",name=" +this.getName() + ", sex=" + this.getSex() + ", age=" +this.getAge() + "]";}
}
创建一个Main测试类
public class Main {public static void main(String[] args) {Person p1 = new Person(); Student s2 = new Student("王二狗子", "boy", 10, 1, 90);System.out.println(s2);}
}
多态
- 编译时多态:一个接口(方法),多种实现(方法的重载)
- 运行时多态:父类可以接收子类对象
- 多态的作用:
屏蔽子类差异化,写出通用的代码
运行时多态的前提是建立在继承的基础之上!
创建一个Bird类
public class Bird {public void fly() {System.out.println("飞扬的小鸟");}
}
创建一个Chicken子类
public class Chicken extends Bird {@Overridepublic void fly() {System.out.println("一只小鸡"); }
}
创建一个Duck子类
public class Duck extends Bird {@Overridepublic void fly() {System.out.println("一只鸭子");}
}
创建一个Goose子类
public class Goose extends Bird {@Overridepublic void fly() {System.out.println("一只会飞的鹅");}
}
创建一个测试类
public class Main {public static void main(String[] args) {Bird bird=new Bird();Goose goose=new Goose();Duck duck=new Duck();Chicken chicken=new Chicken();//方法一bird.fly();goose.fly();duck.fly();chicken.fly();//方法二Bird[] birds= {bird,goose,duck,chicken};for(int i=0;i<birds.length;i++) {Bird b=birds[i];b.fly();}//foreach 格式/* for( 遍历出来的对象 : 要遍历的数组 ){* }*/for (Bird bird2 : birds) {bird2.fly();}}
}
接口
接口: 方法的列表!
只需要声明方法,不需要实现!
可以理解为方法清单
接口:把公共的功能和属性组合起来!封装成标准的特定集合
接口中的方法:
- 默认修饰符public
- 默认都是抽象方法,只需要声明不需要实现的方法!
接口中的属性:
- 访问属性的修饰符默认是public
- 默认是静态属性static
- 默认带有final 变量值不可再被修改!
- 一个类只可以继承一个父类!
- 一个类可以实现多个接口!
- 一旦实现某个接口,就必须实现接口中的所有方法!
定义一个Runlist接口
public interface RunList {public void run();public void color();
}
定义第二个接口TwoInterface
public interface TwoInterface {public void wheel();
}
定义一个类实现接口
public class Car implements RunList,twoInterface {//只要实现了接口 就必须实现方法@Overridepublic void run() {System.out.println("车会跑");}@Overridepublic void color() {System.out.println("车有颜色");}@Overridepublic void wheel() {System.out.println("4个轮子"); }
}
定义一个测试类Main
public class Main {public static void main(String[] args) {RunList runlist=new Car();runlist.run();runlist.color(); }
}
抽象类
abstract关键字
注意: abstract只能修饰类和方法!
特点:
- 抽象方法必须放在抽象类中
- 抽象方法省略{}部分,只需要声明方法即可!
- 抽象类–>被子类继承–>创建对象(其实就是抽象类不可以new 对象)
- 抽象类中可以有普通方法,也可以有抽象方法
- 非抽象类继承抽象类时,子类必须重新写抽象类中的抽象方法
定义一个抽象类
public abstract class Player {public String name;public void sleep() {System.out.println("来来来!一起睡觉了");}//抽象方法public abstract void sports();
}
定义一个子类继承父类
public class PingPongPlayer extends Player {//子类必须实现父类的抽象方法@Overridepublic void sports() {System.out.println("来来,相互扇一扇");}
}
定义第二个子类
public class FoolballPlayer extends Player {@Overridepublic void sports() {System.out.println("相互提一提");}
}
定义一个测试类
public class Main {
public static void main(String[] args) {//抽象类-->被子类继承-->创建对象(其实就是抽象类不可以newPlayer player=new PingPongPlayer()player.name="邓亚萍";FoolballPlayer foolballPlayer=new FoolballPlayer();foolballPlayer.name="吴磊";player.sleep();foolballPlayer.sports();player.sports();}
}
抽象类与普通类的区别:
- 抽象类不能new对象;但实现它方法的子类可以new对象
- 抽象类可以写抽象方法,但其普通子类必须实现该方法
- 如果一个普通类实现了一个抽象接口或者抽象类,那么意味着必须重写抽象方法
- 普通类中不能有抽象方法
- 如果一个类中有抽象方法这个类必须定义为抽象类
抽象类与接口的区别与联系
区别:
- 抽象类要被子类继承,接口要被类实现
- 接口只能做方法声明,抽象类中可以作方法声明,也可以做方法实现
- 接口里定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量
- 接口是设计的结果,抽象类是重构的结果
- 抽象类和接口都是用来抽象具体对象的,但是接口的抽象级别最高
- 抽象类可以有具体的方法和属性,接口只能有抽象方法和不可变常量
- 抽象类主要用来抽象类别,接口主要用来抽象功能
联系:
- 二者都不能直接new对象
- 一个类只能继承一个抽象类,可以实现多个接口(也可以说多继承)
但必须记住继承只能有一个m
更多推荐
JavaOOP(面向对象)学习体会
发布评论