java面向对象
Object Oriented Programming 简称OOP是当前主流的编程思想，将解决问题的所有参与对象创建出来，赋予对象对应的行为和属性让这些对象互相配合完成，实现最终效果。这种思想致力于将计算机中的世界，描述的和现实中一致。
一、类和对象
具有相同的属性（变量）和行为（方法）的对象的集合称为一类。对象是类的具体实例，是类的具体表现。
二、面向对象的三大基本特征
封装
使用private关键字进行修饰，可以防止除自身类之外的地方对该属性进行访问。再提供一组公开的get/set方法对属性进行赋值和读取。
继承
继承后子类可以访问父类中的非私有属性和方法。Java是单继承，一个子类只能有一个父类，每个类都有一个共同的父类：**Object；**在创建子类对象时会先执行父类中的构造方法。子类对父类的方法进行重写后，子类调用的方法是重写后的方法。
public class Father{
public Father(){
fun();
}
public void fun(){
System.out.println("父类中的普通方法");
}
}
public class Son extends Father{
public Son(){
fun();
}
public void fun(){
System.out.println("子类中的普通方法");
}
}
public class Test{
public static void main(String[] args){`
new Father();
new Son();
}
}
//最终输出
父类中的普通方法
子类中的普通方法
子类中的普通方法
多态
多态是面向对象语言的一种特性，通常在代码中用于：需要使用一个父类对象时，实际传递的是一个子类对象，这时可以将子类对象当做父类对象使用。这种特性称为多态。多态免去了重载的过程，只定义一个参数为父类对象的方法，实际传递子类对象，调用方法时执行的是子类重写后的内容。在需要父类对象时，将子类对象当做父类对象使用。这时父类对象调用的是子类重写后的方法，不能调用子类中父类没有的方法。
抽象abstract
可以修饰类和方法，抽象类中，一定包含抽象方法，抽象方法没有方法体。
抽象方法只能定义在抽象类或接口中，抽象方法通常需要子类重写。abstract不能修饰构造方法和静态方法。
抽象类的特点
抽象类不能实例化(不能创建抽象类的对象)抽象类中可以有抽象方法，也可以有普通方法、构造方法(除抽象方法外和普通类一样)，抽象类的构造方法在创建其子类对象时自动执行，但不会创建抽象类的对象某个类如果继承了抽象类，那么这个类要么也是抽象类，否则就要重写抽象类中的所有抽象方法，通常抽象类都需要子类继承后重写其中的抽象方法。
接口
假如一个抽象类中的所有方法都是抽象方法，那么就可以把这个类定义为一个接口。由于java是单继承，如果类A想要继承多个"父类"中的内容时，就不能使用extends，但可以使用implements实现多个接口而达到多继承的目的。接口是一个完全抽象类，其中的方法都是被public abstract修饰的公开抽象方法，其中的属性，都是被public static final修饰的公开的静态常量，需要在定义时赋值才能使用。接口和抽象类一样，通常需要子类继承，但继承接口，称为"实现接口"。使用implements关键字实现。
接口的特点
接口不能实例化；接口中的抽象方法默认使用public abstract修饰，属性默认使用public static final修饰；接口中没有构造方法和普通方法；jdk1.8后，接口中允许定义"default修饰的默认方法"和"static修饰的静态方法"；接口的实现类，必须重写接口中的抽象方法；
匿名内部类
定义在类中，没有名字的类。如果某个方法的参数是接口或抽象类时，通常需要创建其子类或实现类才能使用，但也可以通过传递一个匿名内部类来使用。
public interface USB{
void start();
}
//定义需要用到接口的类
public class Computer{
//该方法的参数本应为一个USB接口类型的数据
void powerOn(USB usb){
usb.start();
}
}
public class Main{
public static void main(String[] args){
Computer c= new Coumpter();
//以下代码中powerOn()方法里的参数就是一个匿名内部类
c.powerOn(new USB(){
private String name;
@override
void start(){
System.out.println(name+"设备启动");
}
USB init(String name){
this.name=name;
return this;
}
}.init("键盘"));
}
}
static关键字的特点
被static修饰的属性、方法或代码块称为静态成员，随着类加载而加载到内存中，只加载一次；静态成员无需对象参与，通过类名即可访问，也可以使用对象访问；静态方法中不能使用非静态成员，可以在静态方法中定义局部变量；静态代码块随着类加载而执行一次，优先于构造方法执行。
可变参数
public void getSum(int...nums){
int sum=0;
for(int num : nums){
sum+=num;
}
System.out.println(sum);
}
public static void main(String[] args){
getSum(1,3,4,2);//输出10
}
final、finally、finalize的区别
finalize是一个方法名，即finalize()方法，属于Object类。在某个对象被垃圾回收机制GC当做垃圾处理时调用。
面向对象综合练习——简单模拟购物商城
用户类（user）
import java.util.Objects;
public class User {
private String username;
private String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User() {
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return Objects.equals(username, user.username) && Objects.equals(password, user.password);
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
@Override
public int hashCode() {
return Objects.hash(username, password);
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
UserDao
package test.dao;
import test.entity.User;
import java.util.Scanner;
public class UserDao {
private User[] users = new User[100];
public UserDao(User[] users) {
this.users = users;
}
public UserDao() {
}
public User[] getUsers() {
return users;
}
public void setUsers(User[] users) {
this.users = users;
}
Scanner sc = new Scanner(System.in);
public void userRegister(User user) {
for (int i = 0; i < users.length; i++) {
if (i > 0 && !(user.equals(users[i]))) {
System.out.println("用户名或密码错误");
break;
}
if (users[i] == null) {
users[i] = user;
System.out.println("注册成功");
break;
}
}
}
public boolean userLogin(String name, String password) {
for (int i = 0; i < users.length; i++) {
if (users[i] == null) {
System.out.println("用户名或密码错误");
return false;
}
if (users[i].getUsername().equals(name) && users[i].getPassword().equals(password)) {
return true;
}
}
System.out.println("用户名或密码错误");
return false;
}
}
管理员类（AdminDao）
package test.entity;
import java.util.Objects;
public class Admin {
private String name;
private String password;
public Admin(String name, String password) {
this.name = name;
this.password = password;
}
public Admin() {
}
@Override
public String toString() {
return "Admin{" +
"name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Admin admin = (Admin) o;
return Objects.equals(name, admin.name) && Objects.equals(password, admin.password);
}
@Override
public int hashCode() {
return Objects.hash(name, password);
}
}
AdminDao
package test.dao;
import test.entity.Admin;
import java.util.Scanner;
public class AdminDao {
private Admin[] admins=new Admin[100];
Scanner sc=new Scanner(System.in);
CommodityDao commodityDao=new CommodityDao();
public AdminDao() {
}
public AdminDao(Admin[] admins) {
this.admins = admins;
}
public Admin[] getAdmins() {
return admins;
}
public void setAdmins(Admin[] admins) {
this.admins = admins;
}
public void adminRegister(Admin admin){
for (int i = 0; i < admins.length; i++) {
if (i>0&&!(admin.equals(admins[i]))){
System.out.println("用户名或密码错误");
break;
}
if (admins[i]==null){
admins[i]=admin;
System.out.println("注册成功");
break;
}
}
}
public boolean adminLogin(String name,String password){
for (int i = 0; i < admins.length; i++) {
if (admins[i]==null){
System.out.println("用户名或密码错误");
return false;
}
if (admins[i].getName().equals(name)&&admins[i].getPassword().equals(password)){
return true;
}
}
System.out.println("用户名或密码错误");
return false;
}
}
商品类（Commodity）
package test.entity;
import java.util.Objects;
public class Commodity {
private String name;
private int number;
private double price;
public Commodity(String name, int number, double price) {
this.name = name;
this.number = number;
this.price = price;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Commodity() {
}
@Override
public String toString() {
return "Commodity{" +
"name='" + name + '\'' +
", number=" + number +
", price=" + price +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Commodity commodity = (Commodity) o;
return number == commodity.number && Double.compare(commodity.price, price) == 0 && Objects.equals(name, commodity.name);
}
@Override
public int hashCode() {
return Objects.hash(name, number, price);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
CommodityDao
package test.dao;
import test.entity.Commodity;
import java.util.Scanner;
public class CommodityDao {
private Commodity[] commodities=new Commodity[100];
public CommodityDao(Commodity[] commodities) {
this.commodities = commodities;
}
public CommodityDao() {
}
public Commodity[] getCommodities() {
return commodities;
}
public void setCommodities(Commodity[] commodities) {
this.commodities = commodities;
}
public void add(Commodity commodity){
for (int i = 0; i < commodities.length; i++) {
if (i>0&&commodities[i-1].equals(commodity)){
System.out.println("商品已经存在");
break;
}
if (commodities[i]==null){
commodities[i]=commodity;
System.out.println("添加成功");
break;
}
}
}
public void show(){
for (int i = commodities.length - 1; i >= 0; i--) {
if (commodities[i]!=null){
System.out.println(commodities[i]);
}
}
}
public Commodity show_one(String name){
for (int i = 0; i < commodities.length; i++) {
if (commodities[i]!=null&&name.equals(commodities[i].getName())){
return commodities[i];
}
}
return null;
}
}
ShopService
package test.dao;
import test.entity.Commodity;
import java.util.Scanner;
public class CommodityDao {
private Commodity[] commodities=new Commodity[100];
public CommodityDao(Commodity[] commodities) {
this.commodities = commodities;
}
public CommodityDao() {
}
public Commodity[] getCommodities() {
return commodities;
}
public void setCommodities(Commodity[] commodities) {
this.commodities = commodities;
}
public void add(Commodity commodity){
for (int i = 0; i < commodities.length; i++) {
if (i>0&&commodities[i-1].equals(commodity)){
System.out.println("商品已经存在");
break;
}
if (commodities[i]==null){
commodities[i]=commodity;
System.out.println("添加成功");
break;
}
}
}
public void show(){
for (int i = commodities.length - 1; i >= 0; i--) {
if (commodities[i]!=null){
System.out.println(commodities[i]);
}
}
}
public Commodity show_one(String name){
for (int i = 0; i < commodities.length; i++) {
if (commodities[i]!=null&&name.equals(commodities[i].getName())){
return commodities[i];
}
}
return null;
}
}
main
package test;
import test.service.ShopService;
public class Main {
public static void main(String[] args) {
ShopService shopService=new ShopService();
shopService.Menu();
}
}
3743
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
