面向对象
面向过程:
面向对象:
A:是一种更符合我们思考习惯
B:可以将复杂的事情简单化
c:将我们从执行者变为指挥者
案列:
面向过程:
买电脑:
了解电脑的信息–>电脑的基本需求–>找到电脑对应得参数–>去电脑城买–>付款–>回来
面向对象:
打电话(电脑城客服)—->上门登记信息–>(客服)送电脑。
万事万物皆对象
大象装冰箱:
A:打开冰箱
B:装进冰箱
C:关闭冰箱
面向过程(编写):
public staic void main(String arg[]){
open();
intin();
close();
}
public void open()
{
systeam.out.println(“开门”)
}
public void open()
{
systeam.out.println(“装进去”)
}
public void close()
{
systeam.out.println(“关闭”)
}
面向对象实现:
clss 大象{
public void open()
{
systeam.out.println(“装进去”)
}
}
class 冰箱{
public void open()
{
systeam.out.println(“开门”)
public void close()
{
systeam.out.println(“关闭”)
}
}
面向对象三大特征:
封装:
继承:
多态:
我们为什么学习编程语言?
答:是为了模拟现实世界的事物,实现信息化。
事物:
属性:
行为
类:
成员变量,
成员方法,
定义一个类就是定义成员方法和成员变量
定义学生类:
class student{
String name;
int id;
ect();
}
public void ect()
{
}
封装的使用
封装:隐藏对外的实现细节,对外提供公共的访问方式。
在封装中尽量把成员变量用private修饰。提供对应的ges/set方法
this的使用:代表当前的类的使用。
class student{
private String name;
Private int age;
}
public void setName(String name)
{
this.name=name;
}
public String getName(){
return name;
}
public void setInt(int age)
{
this.age=age;
}
public int getInt(){
return age;
}
构造方法:
A:方法名和类名相同
B:没有返回值类型,连VOID都没有。
c:没有具体的返回值
public student(){};
构造方法的重载:
public student (string name){
}
public student (int age){}
public student(int age,String name){}
总结:给成员变量赋值有两种方法:通过setxxx和构造方法。
类的组成:成员变量,成员方法,构造方法。
static的特点
1.随着内的加载而加载
2.既可以修饰成员变量,也可以修饰成员方法
3.优先于对象存在
4.被所以对象所共享
5.可以通过类名调用
注意事项:
1静态方法访问只能访问静态成员变量和静态成员方法,
2在静态中没有this关键字。
(5)静态变量和成员变量的区别
A:所属不同
静态变量:属于类,类变量
成员变量:属于对象,对象变量,实例变量
B:内存位置不同
静态变量:方法区的静态区
成员变量:堆内存
C:生命周期不同
静态变量:静态变量是随着类的加载而加载,随着类的消失而消失
成员变量:成员变量是随着对象的创建而存在,随着对象的消失而消失
D:调用不同
静态变量:可以通过对象名调用,也可以通过类名调用
成员变量:只能通过对象名调用
多态的理解和识记
什么叫多肽?
某一个事物在不同时刻表现出来的不同状态。及事物多种形态。
案列1:
猫是猫,
猫是动物。
动物 d=new 猫()
案列2:
水(液态,固态,气态)温度不同变化也不同。
多肽的前提:
A:要有集成
B:要有方法重写
c:要有父类引用指向子类对象
父 F=new 子();
案列3:
class Fu{
public void show(){
Systeam.out.println("show zi");
}
}
class zi extends Fu{
public void show(){
Systeam.out.println("show zi");
}
}
class dome{
public static void main(String []args){
Fu f=new zi();
}
}
编译看左边,运行看左边。
多肽的好处
A:提高了代码的维护性
B:提高了代码的拓展性
案列 猫狗案列:
public class Animal{
public void cet(){
systeam.out.println("ect);
}
public void sleep(){
systeam.out.println("sleep);
}
}
}
class dog extends Animal{
public void cet(){
systeam.out.println("dog 吃肉);
}
public void sleep(){
systeam.out.println("站着sleep);
}
}
}
class cat extends Animal{
public void cet(){
systeam.out.println("cat 吃肉);
}
public void sleep(){
systeam.out.println("趴着leep);
}
}
}
多肽的弊端:
不能使用子类特有的功能。
抽象的概述
必须用abstract关键字修饰
抽象的特点:
1.抽象方法不能有主体。
2.抽象中不一定有方抽象法,但是有抽象方法的类必须定义为抽象类。
3.抽象不能实列化
4.抽象方法有构造方法,但是不能实列化
案列分析
/*
假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。
经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
分析:
普通员工类
成员变量:姓名、工号以及工资。
成员方法:工作
经理类:
成员变量:姓名、工号以及工资,奖金属性
成员方法:工作
实现:
员工类:
普通员工类:
经理类:
//定义员工类
abstract class Employee {
//姓名、工号以及工资
private String name;
private String id;
private int salary;
public Employee() {}
public Employee(String name,String id,int salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
//工作
public abstract void work();
}
//普通员工类
class Programmer extends Employee {
public Programmer(){}
public Programmer(String name,String id,int salary) {
super(name,id,salary);
}
public void work() {
System.out.println("按照需求写代码");
}
}
//经理类
class Manager extends Employee {
//奖金
private int money; //bonus 奖金
public Manager(){}
public Manager(String name,String id,int salary,int money) {
super(name,id,salary);
this.money = money;
}
public void work() {
System.out.println("跟客户谈需求");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
class AbstractTest4
{
public static void main(String[] args) {
//测试普通员工
Employee emp = new Programmer();
emp.setName("林青霞");
emp.setId("czbk001");
emp.setSalary(18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");
emp = new Programmer("林青霞","czbk001",18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");
/*
emp = new Manager();
emp.setName("刘意");
emp.setId("czbk002");
emp.setSalary(8000);
emp.setMoney(2000);
*/
//由于子类有特有的内容,所以我们用子类来测试
Manager m = new Manager();
m.setName("刘意");
m.setId("czbk002");
m.setSalary(8000);
m.setMoney(2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
System.out.println("-------------");
//通过构造方法赋值
m = new Manager("刘意","czbk002",8000,2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
}
}
接口的概述
接口的特点:
1.用interface来修饰
2.类实现接口用implement表示
3.接口不能列化
1.类与类:只能单继承,可以多层继承
2.类与接口:可以单实现,也可以多实现,
3.接口与接口:继承,也可以多继承,
抽象类与接口的区别
A:成员区别
抽象类:
接口:
B:关系区别:
类与类:
类与接口:
接口与接口:
C:设计理念不同
抽象类:is a,抽象类中定义的是共性功能。
接口:like a,接口中定义的是扩展功能。
案列
*
猫狗案例,加入跳高的额外功能
分析:从具体到抽象
猫:
姓名,年龄
吃饭,睡觉
狗:
姓名,年龄
吃饭,睡觉
由于有共性功能,所以,我们抽取出一个父类:
动物:
姓名,年龄
吃饭();
睡觉(){}
猫:继承自动物
狗:继承自动物
跳高的额外功能是一个新的扩展功能,所以我们要定义一个接口
接口:
跳高
部分猫:实现跳高
部分狗:实现跳高
实现;
从抽象到具体
使用:
使用具体类
//定义跳高接口
interface Jumpping {
//跳高功能
public abstract void jump();
}
//定义抽象类
abstract class Animal {
//姓名
private String name;
//年龄
private int age;
public Animal() {}
public Animal(String name,int age) {
this.name = name;
this.age = age;
}
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 abstract void eat();
//睡觉(){}
public void sleep() {
System.out.println("睡觉觉了");
}
}
//具体猫类
class Cat extends Animal {
public Cat(){}
public Cat(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("猫吃鱼");
}
}
//具体狗类
class Dog extends Animal {
public Dog(){}
public Dog(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("狗吃肉");
}
}
//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
public JumpCat() {}
public JumpCat(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高猫");
}
}
//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
public JumpDog() {}
public JumpDog(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高狗");
}
}
class InterfaceTest {
public static void main(String[] args) {
//定义跳高猫并测试
JumpCat jc = new JumpCat();
jc.setName("哆啦A梦");
jc.setAge(3);
System.out.println(jc.getName()+"---"+jc.getAge());
jc.eat();
jc.sleep();
jc.jump();
System.out.println("-----------------");
JumpCat jc2 = new JumpCat("加菲猫",2);
System.out.println(jc2.getName()+"---"+jc2.getAge());
jc2.eat();
jc2.sleep();
jc2.jump();
//定义跳高狗并进行测试的事情自己完成。
}
}