java面向对象

最新推荐文章于 2022-11-21 22:29:45 发布

qq_41964407

最新推荐文章于 2022-11-21 22:29:45 发布

阅读量201

点赞数

本文链接：https://blog.csdn.net/qq_41964407/article/details/79849316

版权

OOP面向对象
对象：是指具体的事物（万物）
类：是对对象的抽象
对象object，instance实例，以后我们说某个类的对象，某个类的实例，
对象和类的关系：
特殊到一般，具体到抽象
类可以看成一个类对象的模板，对象可以看成该类的一个具体实例，
类是用于描述同一个类形的对象的一个抽象概念，
构造器的作用：
就是可以按照构造器的结构产生一个对应的对象
构造方法不同能够实现不同的初始化，用来进行参数赋值
this java中代表对象本身
创建一个对象的方法，new 一个对象
new关键字调用的是类的构造方法，通过类的构造方法可以产生一个新的对象。
public class Persons{
String name;
int age;
public void Persons(String name,int age){
this.name = name;
this.age =age;
}
public Persons(String name,int age){
this.name= name;
this.age =age;
}

public static void main(String []args){
Persons xiaoMing =new Persons("小明", 25);
System.out.println(xiaoMing.name);
System.out.println(xiaoMing.age);*/

}
}

（1）普通方法中使用this
区分类成员属相和方法的形参
调用当前对象的其他方法
位置：任意
（2）构造方法中使用this
使用this来调用其他构造方法
位置：必须是第一条语句，
（3）this不能用于static方法
（4）static
修饰成员变量：静态变量：可以实现多个对象之间变量共享
修饰成员方法：静态方法：可以通过类名直接进行调用，类名.方法（）；
（5）语句块
static[
]
静态初始化语句块
（6）pakage（包）
为什么需要pakage？
为了解决类之间的重名问题，
为了便于管理类：合适的类位于合适的包
（7）pakage怎么用？
类的第一句，非注释语句
（8）import static
静态导入的作用：导入指定类的静态属性。
习题一个（创建一个教师类，属性有姓名，年龄，性别和教师编号；提供本类的无参和全参构造方法，编写教师上课方法。编写静态方法放学，方法打印“放学了”方法打印xxx老师在上课。xxx是教师姓名。在main方法中创建两个教师类的对象并进行初始化，分别调动两个老师的上课方法，判断两个对象是否相等并打印结果，最后通过类名调用放学方法）
package com.sxt;
/**
* 教师类
* @author Gramer
*
*/
public class Teacher {
//属性
String name;
int age;
String sex;
String tno;
//无参构造方法
public Teacher(){

}
//全参构造方法
public Teacher(String name,int age,String sex,String tno){
this.name=name;
this.age=age;
this.sex=sex;
this.tno=tno;
}
//教师上课方法teach
void teach(){
System.out.println(name+"在进行PPT演示面向对象");
}
void teach1(){
System.out.println(name+"在进行课堂纪律管控");
}
//静态方法放学了close
static void close(){
System.out.println("放学了");
}
public static void main(String[]args){
Teacher js = new Teacher("范老师",18,"男","20170701");
Teacher js1 = new Teacher("任老师",18,"男","20170702");
js.teach();
js1.teach1();
System.out.println(js==js1);
Teacher.close();
}
}

面向对象的三大特征：封装，继承，多态
封装的作用：安全
隐藏对象内部的复杂性，只对外公开简单的接口便于外界调用，从而提高系统扩展性，可维护性。
程序设计的要求：高内聚，低耦合。
成员访问权限的四种：
公开的：可以被项目中所有类访问
受保护的：可以在同一包中所有类都可以使用，被他子类访问
default/friendly 默认的/友好的，被本身访问，同一个包访问
私有的只能被这个类本身访问
get/set方法
private私有属性一般会提供公共的get/set方法，以便对外界，对我私有属性进行读写。
get获取属性，要有返回值（boolean 是is）
set改变属性，提供参数
继承
子类extends父类
子类继承父类，子类拥有父类的非私有属性和方法
java中只有单继承，没有c++那样的多继承，多继承会产生混乱，
子类不能继承父类的构造方法
子类在使用自己的构造方法的时候，会先去调用祖先的构造方法依次到本类为止。
多态：
重载，重写
重写：在子父类之间，子类的方法名，返回值和参数列表都一样，但是方法体不一样。
重载：在同一个类中，方法名相同，方法参数类型不同，
多态：多样化
object 对象类，他是所有java类的父类（根基类）
如果一个类没有继承任何类，这个类就继承object类
super代表父类本身，this代表当前对象本身
==和equals的区别：
==可以用来进行基本数据类型值得比较，
引用数据类型==比较的是内存地址是否相等
equals用来比较两个对象的内容是否相等。
/**
* 汽车类
* @author Gramer
*
*/
public class Car {
String chexing;
String chepai;
public Car(){

}
public void start(){
System.out.println("我是车，我启动");
}
public void Stop(){
System.out.println("我是车，我停止");
}
}
/**
* 出租车类
* @author Gramer
*
*/
public class Taxi extends Car{
String qcgs;
public Taxi(){

}
public void customer(){
System.out.println("乘客你好");
System.out.println("我是景顺出租车公司的，我的车牌号是京B123，你要去哪里");
System.out.println("目的地已经到了，请您付费下车，欢迎再次乘坐");
}
}
/**
* 家用轿车
* @author Gramer
*
*/
public class FamilyCar extends Car{
String name;
public FamilyCar(){
}
public void outing(){
System.out.println(“我是武大郎，我的汽车我做主 “);
System.out.println(“目的地到了，我们去玩吧”);
}
}
public class Cartest {
public static void main(String []args){
Taxi a = new Taxi();
FamilyCar b = new FamilyCar();
a.start();
a.Stop();
b.outing();
a.customer();
}

}

多态
多态存在的三个必要条件
继承，重写，父类的引用指向子类对象
A instanceof B 用来判断A对象和B对象是否是同一种类型，是返回true，否则返回false。
子类转换父类（向上转型）自动转型
上转型对象不能操作子类新增成员的变量和方法
上转型对象可以操作子类继承或重写的成员变量和方法
父类转换子类（强制转换）注意类型转换异常
final 可以用来修饰：变量，方法，类
修饰属性：修饰一个变量，这个变量就变成常量，
修饰方法：方法不能被子类重写。
修饰类：这个类不能被继承
抽象类：
是一种模板模式，抽象类为所有子类提供了一个通用模板，子类可以在这个模板基础上进行扩展。
通过抽象类，可以避免子类设计的随意性。
abstract 抽象方法的关键字
修饰类变成抽象类，
修饰方法变成抽象方法，抽象方法的意义是为了让子类重写，没有方法体。
抽象类的定义：一个被abstract修饰的类就是抽象类。
包含一个抽象方法的类就是抽象类（抽象类不一定有抽象方法）
static final 修饰一个变量，变成全局常量。
abstract和final不能连着写，
⦁ 编写程序实现比萨制作。需求说明编写程序，接收用户输入的信息，选择需要制作的比萨。可供选择的比萨有：培根比萨和海鲜比萨。
实现思路及关键代码
⦁ 分析培根比萨和海鲜比萨
⦁ 定义比萨类
⦁ 属性：名称、价格、大小
⦁ 方法：展示
⦁ 定义培根比萨和海鲜比萨继承自比萨类
⦁ 定义比萨工厂类，根据输入信息产生具体的比萨对象

import java.util.Scanner;

/**
* 披萨工厂
* @author Gramer
*
*/
public class Pizzas {
Scanner sc = new Scanner(System.in);

public static void main(String []args){

Pizzas p = new Pizzas();
p.choose();
}
public void choose(){
System.out.println("请输入你要选择制作的披萨1.培根披萨 2.海鲜披萨");
String name = sc.next();
if(name.equals("1")){
int bacon = bacon();
int size =size();
double price =price();
BaconPizza ps = new BaconPizza("培根披萨",price,size,bacon);
ps.show();

}else if(name.equals("2")){
String burdening = burdening();
int size = size();
double price =price();
SeafoodPizza hx = new SeafoodPizza("海鲜披萨",price,size,burdening);
hx.show();
}else if(!name.equals("1") || !name.equals("2")){
System.out.println("输入错误");
choose();
}
}
public int bacon(){
System.out.println("请输入培根数量：");
return sc.nextInt();
}
public String burdening(){
System.out.println("请输入配料信息");
return sc.next();
}
public int size(){
System.out.println("请输入披萨大小");
return sc.nextInt();
}
public double price(){
System.out.println("请输入披萨价格");
return sc.nextDouble();
}
}
package com.eat;

/**
* 披萨
* @author Gramer
*
*/
public abstract class Pizza {
String name;
double price;
int size;
public Pizza(String name,double price,int size){
this.name=name;
this.price=price;
this.size=size;

}
public abstract void show();
}
package com.eat;

/**
* 培根披萨
* @author Gramer
*
*/
public class BaconPizza extends Pizza{
private int bacon;
public BaconPizza(String name, double price, int size,int bacon) {
super(name, price, size);
this.bacon=bacon;
}

@Override
public void show() {
System.out.println("名称："+name+"\n价格："+price+"\n大小"+size+"\n培根克数"+bacon);

}
}
package com.eat;

/**
* 海鲜披萨类
* @author Gramer
*
*/
public class SeafoodPizza extends Pizza{
private String burdening;
public SeafoodPizza(String name, double price, int size,String burdening) {
super(name, price, size);
this.burdening=burdening;
}

@Override
public void show() {
System.out.println("名称："+name+"\n价格："+price+"\n大小："+size+"\n配料："+burdening);
}
}