JavaOOP(面向对象)学习体会

编程入门行业动态更新时间:2024-10-28 11:18:50

JavaOOP(面向对象)<a href=https://www.elefans.com/category/jswz/34/1749522.html style= 学习体会"/>

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();}
}

抽象类与普通类的区别: